- __ __ - /\ \ \ _ __/ /______ - / \/ / / / / __/ ___/ -/ /\ / /_/ / /_(__ ) -\_\ \/\__,_/\__/____/ version 0.7.0.0 + __ __ + /\ \ \ _ __/ /______ + / \/ / / / / __/ ___/ +/ /\ / /_/ / /_(__ ) +\_\ \/\__,_/\__/____/ version 0.7.1.0**nuts** is a Package manager for Java (and other things). It stands for **Network Updatable Things Services** tool. Think of it as **npm** for javascript or **pip** for python. But it lots more... It is a simple tool for managing remote artifacts, installing these artifacts to the current machine and executing such artifacts on need. Each managed artifact is also called a **nuts** which is a **Network Updatable Thing Service** . Nuts artifacts are stored into repositories. A **repository** may be local for storing local Nuts or remote for accessing remote artifacts (good examples are remote maven repositories). @@ -25,20 +25,16 @@ What makes **nuts** very helpful is that it simplifies application deployments b + search : search for existing/installable artifacts + welcome : a command that does nothing but bootstrapping nuts and showing a welcome message. - -Visit [nuts website](http://core-techs-solutions.com/nuts) - - ## Download Latest stable version -+ Linux,Windows,iOS, and Java enabled OS : [nuts-0.7.0.jar](https://github.com/thevpc/vpc-public-maven/raw/master/net/vpc/app/nuts/nuts/0.7.0/nuts-0.7.0.jar) ++ Linux,Windows,iOS, and Java enabled OS : [nuts-0.7.1.jar](https://github.com/thevpc/vpc-public-maven/raw/master/net/vpc/app/nuts/nuts/0.7.1/nuts-0.7.1.jar) + On Unix/Linux platforms you may use : + using **wget** ``` - wget https://github.com/thevpc/vpc-public-maven/raw/master/net/vpc/app/nuts/nuts/0.7.0/nuts-0.7.0.jar + wget https://github.com/thevpc/vpc-public-maven/raw/master/net/vpc/app/nuts/nuts/0.7.1/nuts-0.7.1.jar ``` + or **curl** ``` - curl https://github.com/thevpc/vpc-public-maven/raw/master/net/vpc/app/nuts/nuts/0.7.0/nuts-0.7.0.jar > nuts-0.7.0.jar + curl https://github.com/thevpc/vpc-public-maven/raw/master/net/vpc/app/nuts/nuts/0.7.1/nuts-0.7.1.jar > nuts-0.7.1.jar ``` Note that you will need a valid Java Runtime Environment (JRE) or Java Development Kit (JDK) version **8** or later to run **nuts**. @@ -48,7 +44,7 @@ It will create all needed configuration files upon the very first launch. More details are available at [wiki installation page](https://github.com/thevpc/nuts/wiki/Installation) ``` -java -jar nuts-0.7.0.jar +java -jar nuts-0.7.1.jar ``` Yous should then see some log like the following : @@ -71,16 +67,16 @@ All tests where performed on OpenSuse Tumbleweed. ## Windows Systems On Windows systems, first launch will create a new Nuts Menu (under Programs) and a couple of Desktop shortcuts to launch a configured command terminal. - + **nuts-cmd-0.7.0** : this shortcut will open a configured command terminal. **nuts** command will be available as well + + **nuts-cmd-0.7.1** : this shortcut will open a configured command terminal. **nuts** command will be available as well as several nuts companion tools installed by **ndi** by default - + **nuts-cmd** : this shortcut will point to the last installed **nuts** version, here 0.7.0 + + **nuts-cmd** : this shortcut will point to the last installed **nuts** version, here 0.7.1 Any of these shortcuts will launch a nuts-aware terminal. Supported Windows systems include Window 7 and later. ## MacOS Systems -Installation will worl seemlely on MacOS as far as you are using bash shell. All Linux installatio notes apply then. +Installation will work seamlessly on MacOS as far as you are using bash shell. All Linux installation notes apply then. ## Test Installation To test installation the simplest way is to open a nuts-aware terminal and type : @@ -92,7 +88,7 @@ nuts --version It should show a result in the format : nuts-api-version/nuts-impl-version ``` -00.7.0/0.7.0.0 +00.7.1/0.7.1.0 ``` ## Run a command @@ -120,13 +116,3 @@ Nuts have lots of ways to be improved. Please feel free to join the journey. View stable releases in [official releases page](https://github.com/thevpc/nuts/releases). View all releases in [release details page](docs/change-log/release-details.md). - -## Read more - -- [Introduction, Why and What for](docs/articles/01-nuts-introduction.md) -- [Project and Repository Organization](docs/articles/02-nuts-projects.md) -- [Nuts Text Coloring Format](docs/articles/04-nuts-text-coloring-format.md) -- [File System](docs/articles/03-nuts-filesystem.md) -- [Commandline Format](docs/articles/05-nuts-commandline.md) -- [FAQ](docs/articles/10-nuts-faq.md) -- [Troubleshooting](docs/troubleshooting.md) \ No newline at end of file diff --git a/README.md.pre b/README.md.pre index 57c773f12..2af8628b0 100644 --- a/README.md.pre +++ b/README.md.pre @@ -79,7 +79,7 @@ Any of these shortcuts will launch a nuts-aware terminal. Supported Windows systems include Window 7 and later. ## MacOS Systems -Installation will worl seemlely on MacOS as far as you are using bash shell. All Linux installatio notes apply then. +Installation will work seamlessly on MacOS as far as you are using bash shell. All Linux installation notes apply then. ## Test Installation To test installation the simplest way is to open a nuts-aware terminal and type : diff --git a/_pre-deploy.sh b/_pre-deploy.sh new file mode 100755 index 000000000..733a581df --- /dev/null +++ b/_pre-deploy.sh @@ -0,0 +1 @@ +nuts worky process-file *.pre diff --git a/app-include.pre-script b/app-include.pre-script index bc0009d68..6dbe001b4 100644 --- a/app-include.pre-script +++ b/app-include.pre-script @@ -1,3 +1,3 @@ -apiVersion='0.7.0'; -implVersion='0.7.0.0'; +apiVersion='0.7.1'; +implVersion='0.7.1.0'; jarLocation=processString("https://github.com/thevpc/vpc-public-maven/raw/master/net/vpc/app/nuts/nuts/${apiVersion}/nuts-${apiVersion}.jar"); \ No newline at end of file diff --git a/website/nuts2/static/.nojekyll b/docs/.nojekyll similarity index 100% rename from website/nuts2/static/.nojekyll rename to docs/.nojekyll diff --git a/docs/01a85c17.b59f7186.js b/docs/01a85c17.b59f7186.js new file mode 100644 index 000000000..7ce316a5a --- /dev/null +++ b/docs/01a85c17.b59f7186.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[4],{56:function(e,a,t){"use strict";t.r(a);var n=t(0),c=t.n(n),l=t(123),r=t(121);a.default=function(e){const{tags:a}=e,t={};Object.keys(a).forEach(e=>{const a=function(e){return e[0].toUpperCase()}(e);t[a]=t[a]||[],t[a].push(e)});const n=Object.entries(t).sort(([e],[a])=>e===a?0:e>a?1:-1).map(([e,t])=>c.a.createElement("div",{key:e},c.a.createElement("h3",null,e),t.map(e=>c.a.createElement(r.a,{className:"padding-right--md",href:a[e].permalink,key:e},a[e].name," (",a[e].count,")")),c.a.createElement("hr",null))).filter(e=>null!=e);return c.a.createElement(l.a,{title:"Tags",description:"Blog Tags"},c.a.createElement("div",{className:"container margin-vert--lg"},c.a.createElement("div",{className:"row"},c.a.createElement("main",{className:"col col--8 col--offset-2"},c.a.createElement("h1",null,"Tags"),c.a.createElement("div",{className:"margin-vert--lg"},n)))))}}}]); \ No newline at end of file diff --git a/docs/091f20d6.63b57531.js b/docs/091f20d6.63b57531.js new file mode 100644 index 000000000..58bba8b29 --- /dev/null +++ b/docs/091f20d6.63b57531.js @@ -0,0 +1 @@ +(window.webpackJsonp=window.webpackJsonp||[]).push([[5],{118:function(e,t,n){"use strict";n.d(t,"a",(function(){return d})),n.d(t,"b",(function(){return m}));var r=n(0),o=n.n(r);function a(e,t,n){return t in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function c(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function i(e){for(var t=1;t
We could not find what you were looking for.
Please contact the owner of the site that linked you to the original URL and let them know their link is broken.
Welcome to this blog. This blog is created with Docusaurus 2 alpha.
This is a test post.
A whole bunch of other information.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet
Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
Welcome to this blog. This blog is created with Docusaurus 2 alpha.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet
Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
Welcome to this blog. This blog is created with Docusaurus 2 alpha.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque elementum dignissim ultricies. Fusce rhoncus ipsum tempor eros aliquam consequat. Lorem ipsum dolor sit amet
Blog features are powered by the blog plugin. Simply add files to the blog directory. It supports tags as well!
Delete the whole directory if you don't want the blog features. As simple as that!
nuts comes up with a simple coloring syntax that helps writing better looking portable command line programs.
+standard output is automatically configured to accept the "Nuts Text Coloring Format" (NTCF) syntax.
+Though it remains possible to disable this ability using the --no-color standard option (or programmatically,
+see nuts API documentation). NTCF will be translated to the underlying terminal implementation using ANSI
+escape code on linux/windows terminals if available.
Here after a showcase of available NTCF syntax.
nuts manages multiple workspaces. It has a default one located at ~/.config/nuts (~ is the user home directory). Each workspace handles a database and files related to the installed applications. The workspace has a specific layout to store different types of files relatives to your applications. Nuts is largely inspired by XDG Base Directory Specification and hence defines several store locations for each file type. Such organization of folders is called Layout and is dependent on the current operating system, the layout strategy and any custom configuration.
Supported Store Locations are :
+nuts File System defines the following folders :
nuts defines such distinct folders (named Store Locations) for storing different types of application data according to your operating system.
On Windows Systems the default locations are :
On Linux, Unix, MacOS and any POSIX System the default locations are :
As an example, the configuration folder for the artifact net.vpc.app:netbeans-launcher#1.2.4 in the default workspace in a Linux environment is
And the log file "app.log" for the same artifact in the workspace named "personal" in a Windows environment is located at
When you install any application using the nuts command a set of specific folders for the presented Store Locations are created. For that,
+two strategies exist : Exploded strategy (the default) and Standalone strategy.
In Exploded strategy nuts defines top level folders (in linux ~/.config for config Store Location etc), and then creates withing each top level Store Location a sub folder for the given application (or application version to be more specific). This helps putting all your config files in a SSD partition for instance and make Nuts run faster. However if you are interested in the backup or roaming of your workspace, this may be not the best approach.
The Standalone strategy is indeed provided mainly for Roaming workspaces that can be shared, copied, moved to other locations. A single root folder will contain all of the Store Locations.
As an example, in "Standalone Strategy", the configuration folder for the artifact net.vpc.app:netbeans-launcher#1.2.4 in the default workspace in a Linux environment is
And the log file "app.log" for the same artifact in the workspace named "personal" in the same Linux environment is located at
You can see here that the following folder will contain ALL the data files of the workspace.
whereas in the Exploded strategy the Store Location are "exploded" into multiple root folders.
Of course, your able to configure separately each Store Location to meet your needs.
The following comman will create an exploded workspace
The following comman will create an standalone workspace
The following command will create an exploded workspace and moves all config files to the SSD partition folder /myssd/myconfig
You can type help for more details.
You can write content using GitHub-flavored Markdown syntax.
To serve as an example page when styling markdown based Docusaurus sites.
Emphasis, aka italics, with asterisks or underscores.
Strong emphasis, aka bold, with asterisks or underscores.
Combined emphasis with asterisks and underscores.
Strikethrough uses two tildes. Scratch this.
I'm an inline-style link with title
You can use numbers for reference-style link definitions
Or leave it empty and use the link text itself.
URLs and URLs in angle brackets will automatically get turned into links. http://www.example.com/ or http://www.example.com/ and sometimes example.com (but not on GitHub, for example).
Some text to show that the reference links can follow later.
Here's our logo (hover to see the title text):
Inline-style: 
Reference-style:
Images from any folder can be used by providing path to file. Path should be relative to markdown file.
Colons can be used to align columns.
| Tables | Are | Cool |
|---|---|---|
| col 3 is | right-aligned | \$1600 |
| col 2 is | centered | \$12 |
| zebra stripes | are neat | \$1 |
There must be at least 3 dashes separating each header cell. The outer pipes (|) are optional, and you don't need to make the raw Markdown line up prettily. You can also use inline Markdown.
| Markdown | Less | Pretty |
|---|---|---|
| Still | renders | nicely |
| 1 | 2 | 3 |
Blockquotes are very handy in email to emulate reply text. This line is part of the same quote.
Quote break.
This is a very long line that will still be quoted properly when it wraps. Oh boy let's keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can put Markdown into a blockquote.
Here's a line for us to start with.
This line is separated from the one above by two newlines, so it will be a separate paragraph.
This line is also a separate paragraph, but... This line is only separated by a single newline, so it's a separate line in the same paragraph.
This is a note
This is a tip
This is important
This is a caution
This is a warning
This is a link to another document. This is a link to an external page.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. In ac euismod odio, eu consequat dui. Nullam molestie consectetur risus id imperdiet. Proin sodales ornare turpis, non mollis massa ultricies id. Nam at nibh scelerisque, feugiat ante non, dapibus tortor. Vivamus volutpat diam quis tellus elementum bibendum. Praesent semper gravida velit quis aliquam. Etiam in cursus neque. Nam lectus ligula, malesuada et mauris a, bibendum faucibus mi. Phasellus ut interdum felis. Phasellus in odio pulvinar, porttitor urna eget, fringilla lectus. Aliquam sollicitudin est eros. Mauris consectetur quam vitae mauris interdum hendrerit. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Duis et egestas libero, imperdiet faucibus ipsum. Sed posuere eget urna vel feugiat. Vivamus a arcu sagittis, fermentum urna dapibus, congue lectus. Fusce vulputate porttitor nisl, ac cursus elit volutpat vitae. Nullam vitae ipsum egestas, convallis quam non, porta nibh. Morbi gravida erat nec neque bibendum, eu pellentesque velit posuere. Fusce aliquam erat eu massa eleifend tristique.
Sed consequat sollicitudin ipsum eget tempus. Integer a aliquet velit. In justo nibh, pellentesque non suscipit eget, gravida vel lacus. Donec odio ante, malesuada in massa quis, pharetra tristique ligula. Donec eros est, tristique eget finibus quis, semper non nisl. Vivamus et elit nec enim ornare placerat. Sed posuere odio a elit cursus sagittis.
Phasellus feugiat purus eu tortor ultrices finibus. Ut libero nibh, lobortis et libero nec, dapibus posuere eros. Sed sagittis euismod justo at consectetur. Nulla finibus libero placerat, cursus sapien at, eleifend ligula. Vivamus elit nisl, hendrerit ac nibh eu, ultrices tempus dui. Nam tellus neque, commodo non rhoncus eu, gravida in risus. Nullam id iaculis tortor.
Nullam at odio in sem varius tempor sit amet vel lorem. Etiam eu hendrerit nisl. Fusce nibh mauris, vulputate sit amet ex vitae, congue rhoncus nisl. Sed eget tellus purus. Nullam tempus commodo erat ut tristique. Cras accumsan massa sit amet justo consequat eleifend. Integer scelerisque vitae tellus id consectetur.
Nuts supports a specific format for command line arguments. This format is the format supported in nuts Application Framewok (NAF) and as such all NAF applications support the same command line arguments format.
+Arguments in nuts can be options or non options. Options always start with dash (-).
Options can be long options (starts with double dash) or short options (start with a single dash). +Many arguments support both forms. For instance "-w" and "--workspace" are the spported forms to define the workspace location in the nuts command.
Options can also support a value of type string or boolean. The value can be suffixed to the option while separated with '=' sign or immediately after the option. As an example "-w=/myfolder/myworkspace" and "--workspace /myfolder/myworkspace" are equivalent.
Particularly, when the value is a boolean, the value do not need to be defined. As a result "--skip-companions" and "--skip-companions=true" are equivalent. However "--skip-companions true" is not (because the option is of type boolean) and "true" will be parsed as a NonOption.
To define a "false" value to the boolean option we can either suffix with "=false" or prefix with "!" or "~" sign. +Hence, "--skip-companions=false", "--!skip-companions" and "--~skip-companions" are all equivalent.
Simple options can be grouped in a single word. "-ls" is equivalent to "-l -s". So one should be careful. +One exception though. For portability reasons, "-version" is considered a single short option.
Options starting with "-//" and "--//" are simply ignored by the command line parser.
Options in nuts are regrouped in multiple categories. An option can belong to multiple categories though.
Create Options : such options are only relevant when creating a new workspace. They define the configuration of the workspace to create. They will be ignored when the workspace already exists. Examples include
Open Options : such options are relevant when creating a new workspace or when opening an existing workspace. They define the way commands are executed. Examples include
Exported Options : are passed to sub-nuts-processes that will be created by nuts. For instance when nuts will call the nsh command it will spawn a new process. In such case, these options are passed to the sub-process as environment variable.
Application Options : are options that are by default supported by Applications using NAF (Nuts Application Framework) (as well as Nuts it self).
all nuts options are described in the command help. Just type :
please read Nuts Introduction, Why and What for
nuts stands for "Network Updatable Things Services". It helps managing things (artifacts of any type, not only java).
+The Name also helps depicting another idea : nuts is a good companion and complement to Maven tool. The word maven (MAY-vin), from Yiddish, means a super-enthusiastic expert/fan/connoisseur/Wizard.
+And where wizards are, fools and nuts must be. nuts is the foolish tool to support the deployment and not the build.
+Hence the name.
Not only. nuts supports all packagings supported by maven. This includes pom , jar , maven-plugin , ejb , war , ear , rar.
+However nuts is also intended to support any "thing" including "exe" ,"dll", "so", "zip" files, etc.
+nuts differs from maven as it defines other properties to the artifact descriptor (aka pom in maven) : os (operating system),
+arch (hardware architecture), osdist (relevant for linux for instance : opensuse, ubuntu) and platform (relevant to vm platforms like java vm, dotnet clr, etc).
+Such properties are queried to download the most appropriate binaries for the the current characteristics.
I hoped you would ask this question. Sure. +You can drop me an email to add you as contributor or fork the repository and ping a pull request. +You can also open a new issue for feature implementation to invite any other contributor to implement that feature (or even implement it your self).
The doc folder is intended to include documentation. The wiki also should help.
If by nuts aware you mean that you would download your application and run it using nuts, then you just need to create the application using maven and deploy your application to the public maven central.
+Nothing really special is to be done from your side. You do not have to use plugins like 'maven-assembly-plugin' and 'maven-shade-plugin' to include your dependencies.
+Or, you can also use NAF (nuts Application Framework) make your application full featured "Nuts aware" application.
First of all, NAF is a simple 300k jar so for what it provided to you, you would be surprised. +Indeed, implementing your application using NAF will provide you a clean way to :
seamless integration with nuts and all other NAF applications
support standard file system layout (XDG) where config files and log files are not necessarily in the same folder see Nuts File System for more details.
support application life cycle events (onInstall, onUninstall, onUpgrade),
standard support of command line arguments
dynamic dependency aware class loading
terminal coloring and components (progress bar, etc...)
json,xml,table,tree and plain format support out of the box
pipe manipulation when calling sub processes
advanced io features (persistence Locks, monitored downloads, compression, file hashing....)
standard ways to support and use installed platforms (installed JRE, JDK, ...)
and more...
Sure, you will be able to benefit of all the items in the preceding question but terminal coloring wont be relevant of course. +Check netbeans-launcher in github. It's a good example of how interesting is to use NAF in non terminal applications.
nuts is published under GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later.
You can run any jar using nuts as far as the jar is accessible from one of the supported repositories.
+By default, nuts supports:
You can configure other repositories or even implement your own if you need to.
The jar will be parsed to check form maven descriptor so that dependencies will be resolved and downloaded on the fly. +Then, all executable classes (public with static void main method) are enumerated. You can actually run any of them when prompted. Any jar built using maven should be well described and can be run using its artifact long id.
nuts long ids are a string representation of a unique identifier of the artifact. It has the following form :
for instance, to install netbeans-launcher (which is a simple UI helping launch of multiple instances of netbeans), you can issue
You do agree that this can be of some cumbersome to type. So you can simplify it to :
In this form, nuts will auto-detect both the groupId and the version. The group id is detected if it is already imported (we will see later import a groupId).
+By default, there is a couple of groupIds that are automatically imported :
net.vpc.app (contains various applications of the author)net.vpc.nuts.toolbox (contains various companion tools of nuts, such as nsh, nadmin, ndi, ...)And it turns out, hopefully, that netbeans-launcher belongs to an imported groupId, so we can omit it.
+Besides, if no version is provided, nuts will also auto-detect the best version to execute. If the application is already installed, the version you choose to install will be resolved. If you have not installed any, the most recent version, obviously, will be detected for you.
Any java application can run using nuts but it has to be installed first. If you try to run the application before installing it, you will be prompted to confirm installation.
+To install our favorite application here we could have issued :
But as we have tried to run the application first, it has been installed for us (after confirmation).
One of the key features of nuts is the ability to install multiple versions of the same application.
+We can for instance type :
Now we have two versions installed, the last one always is considered default one. +you can run either, using it's version
Actually, when you have many versions installed for the same artifact and you try to run it without specifying the version, the last one installed will be considered. To be more precise, an artifact has a default version when it is installed. This default version is considered when no explicit version is typed. +In our example, when we type
the 1.2.0 version will be invoked because the artifact is already installed and the default version points to the last one installed. So if you want to switch back to version 1.2.2 you just have to re-install it. Don't worry, no file will be downloaded again, nuts will detect that the version is not marked as default and will switch it to.
Now let's take a look at installed artifacts. We will type :
This will list all installed artifacts. We can get a better listing using long format :
you will see something like
The first column here is a the artifact status that helps getting zipped information of the artifact. the 'I' stands for 'installed and default' whereas, 'i' is simply 'installed'. The 'X' stands for 'executable application', where 'x' is simply 'executable'. Roughly said, executable applications are executables aware of (or depends on) nuts, as they provide a special api that helps nuts to get more information and more features for the application. As an example, executable applications have special OnInstall and OnUninstall hooks called by nuts. +The second and the third columns are date and time of installation. The fourth column points to the installation user. When Secure mode has not been enabled (which is the default), you are running nuts as 'anonymous'. +The fifth column shows the repository from which the package was installed. And the last column depicts the artifact long id.
Let's suppose that my-app.jar is a maven created jar (contains META-INF/maven files) with a number of dependencies. nuts is able to download on the fly needed dependencies, detect the Main class (no need for MANIFEST.MF) and run the
+application. If a Main-Class Attribute was detected in a valid MANIFEST.MF, il will be considered.
+If more than one class is detected with a main method, nuts will ask for the current class to run.
When you run a local file, nuts will behave as if the app is installed (in the given path, an no need to invoke install command). Local files are detected if they are denoted by a valid path (containing '/' or '\' depending on the underlying operating system).
+Dependencies will be downloaded as well (and cached in the workspace)
If you need to pass JVM arguments you have to prefix them with "--exec". So if you want to fix maximum heap size use
Here are all nuts requirements :
nuts requires a valid Java Runtime Environment (JRE) or Java Development Kit (JDK) version 8 or above to execute.nuts memory footprint is very little and has no minimum RAM requirements.nuts installation itself. In addition to that, additional disk space will be used for your local Nuts workspace. The size of your local workspace will vary depending on usage but expect at least 500MB.nuts is able to run on any java enabled Operating System including all recent versions of Windows, Linux and MacOS.To check if you have a valid java installation type
The result would be equivalent to the following. Just be sure the version is 1.8 or over. In this example, +the java version is 13.0.1
Linux Systems installation is based on bash shell. First launch will configure "~/.bashrc" so that nuts and other companion tool commands will be available in any future terminal instances.
+Using nuts on unix-like system should be seamless. A simple bash terminal (Gnome Terminal, KDE Konsole,...) is already a nuts-aware terminal.
All Linux versions and distributions should work with or without XWindow (or equivalent). Graphical system is required only if you plan to run a gui application using nuts. +All tests where performed on OpenSuse Tumbleweed.
Any bash terminal application is a nuts-aware terminal.
Yous should then see some log like the following :
As you can see, installation upon first launch, will also trigger installation of other optional programs called "companion tools". +Actually they are recommended helpful tools :
nuts by for instance creating shortcuts.nuts After installation, you need to restart the terminal application for the configuration to take effet.
To test installation the simplest way is to open a nuts-aware terminal and type :
It should show a result in the format : nuts-api-version/nuts-impl-version
To run a command using nuts just type
Several commands are available, and you still be able to run any java and non java application. More info is available in the nuts official wiki .
nuts stands for Network Updatable Things Services tool. It is a simple tool for managing remote
+artifacts, installing these artifacts to the current machine and executing such artifacts on need.
+Each managed package is also called a nuts which is a Network Updatable Thing Service .
+nuts artifacts are stored into repositories. A repository may be local for storing local nuts
+or remote for accessing remote artifacts (good examples are remote maven repositories). It may
+also be a proxy repository so that remote artifacts are fetched and cached locally to save network
+resources.
+One manages a set of repositories called a workspace. Managed nuts (artifacts) have descriptors
+that depicts dependencies between them. This dependency is seamlessly handled by nuts (tool) to
+resolve and download on-need dependencies over the wire.
nuts is a swiss army knife tool as it acts like (and supports) maven build tool to have an abstract
+view of the the artifacts dependency and like npm, pip or zypper/apt-get package manager tools
+to install and uninstall artifacts allowing multiple versions of the very same artifact to be installed.
nuts and showing a welcome message.This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; either version 3 of the License, or (at your option) any later +version.
This program is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +details.
You should have received a copy of the GNU General Public License along with +this program; if not, write to the Free Software Foundation, Inc., 51 +Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Copyright (C) 2016-2017 Taha BEN SALAH
Is there any package manager for Java(TM) applications? You can google for it and you will find that many have
+queried this on blogs and forums. In most cases responses point to maven and gradle, the tremendous build tools. However,
+both maven and gradle are build tools, while helping build packages they lack of deployment features. They bundle every
+dependency in every package (think of wars, ears and standalone jars). They do not handles installation or upgrading.
+Apache ivy, as well, while competing with maven build tool does not provide more than transitive dependency management.
+The main idea behind a package manager is the automation of installation, update, configuration and removal of programs
+or libraries in a coherent manner with the help of a database that manages binaries and metadata. maven, to consider one,
+sticks to the build process, an goes no further.
You may also ask, "Why ever, do we need a package manager for Java(TM) applications". Okkay, let's take some +example of Java(TM) applications. How can we install apache netbeans IDE ? The proper way is to browse to the editor's +website, select the proper mirror if applicable, download the archive, uncompress it, chmod the main binary (i'm a linux +guy) and adjust PATH environment variable to point to this binary; Quite a pain. What do we do to update it now? Hopefully, +the IDE has a solid plugin architecture and an in-app update/upgrade tool that will help the process (in a gui manner of +course). The same applies to eclipse and apache tomcat with the exception that apache tomcat does not even bundle an in-app +update tool. The same applies too when dealing with other operating systems (Windows, MacOS, ...). Managing Java(TM) +applications is far from helpful.
Furthermore, as Java(TM) applications are (usually) not bundled in OS-aware installers, you will end up with a spaguetty +home directory with applications installed all over your partitions, which - simply - does not mix up with all the work +OS-developers have done to separate logs from data, from temporary files, from binaries, etc. Each application will handle +it's files in a very specific manner that would make it hard to manage own's disk (automatic archive/backup/restore) or roaming +applications across machines, etc.
Moreover, in a world of containers and devops, deployments of Java(TM) applications need to be automatable and reproducible +with the highest level of simplicity, configurability and integrability. Installing tomcat on a custom port should ne not +be as painful as using a custom Docker image or a complicated Dockerfile or even a custom apache tomcat bundle.
When we recall that Java(TM) is the one language that has the more versatile number of libraries, frameworks and tools,
+I find it annoying not to have a decent package manager to make the leap and provide facilities I find prime in other
+languages and platforms (pip/python, npm/nodejs/javascript) and most of linux distribution (zypper/opsensuse, dnf/redhat
+apt-get/debian/ubuntu)
Hence I'm introducing here a humble attempt to provide a tiny (300ko) yet powerful package manager for Java(TM)
+applications (but not only) that should handle jar files seamlessly (with little or no modification) and that comes with
+a set of portable tools that makes this management at a higher level. I'm not talking about redefining the wheel.
+I'm aware that many tools such as maven, are already very good at what they do, I just needed to make the leap for deployments.
+You will be able to deploy your applications without bundling all of their dependencies : nuts will take care of that.
So you'd still be maven, yet you gonna be nuts.
nuts is actually :
nuts calculates transitive dependencies of an application to resolve other packages to download at install or
+update/upgrade time. So typically, deployed applications should no more bundle their dependencies within the deployed archive.
+Thus we avoid the annoying fat jars (using maven plugins like 'maven-assembly-plugin' and 'maven-shade-plugin') and lib folders
+(using 'maven-dependency-plugin'). It will also reuse dependencies and packages across multiple installed applications
+and hence save disk space, and network bandwidth.
All what nuts needs is a descriptor file withing the jar file that defines the immediate dependencies. It then
+calculates all transitive dependencies automatically. And guess what, all maven built jars already contain that
+descriptor : the pom.xml file. So basically all maven applications are already nuts aware applications.
nuts uses this dependency resolution to help install, update, remove and search for applications. To be able to use an
+application, it has to be installed and configured with all of its dependencies. This is the main goal of nuts.
+When we ask to install tomcat, for instance, it will search for the best version in registered repositories, download it,
+and configure it to be ready for execution. The best version is not always the the latest one. Actually it would be the
+latest valid one, thus the latest one that matches some constraints.
+Constraints include the version of the running java (tomcat 8 works on java 7 but not 6 for instance), the running operating
+system (windows, linux, ... to help selecting the proper binaries), may be the hardware architecture or even the
+operating distribution (for linux based systems). Constraints will filter the search result to include the best, the most
+accurate version to install. Installation also would configure the installed application and even may run another
+artifact to help this configuration.
nuts also handles search for newer versions and update the installed application at request. Updating a software does not
+necessarily delete the older version. Both version can coexist and it is up to the user the decide whether or
+not to retain both versions. Indeed, one of the key features of nuts is the ability to install and hence run multiple versions
+of the same software in parallel. You would never see an error message telling you can't install that software because a
+dependencies of it is installed with different version. All software and all libraries can coexist peacefully.
Software artifacts are stored in repositories. nuts can handle multiple repositories, remote and local ones.
+Installed software are store in special local repositories. Supported repositories include maven repositories and github
+repositories. Actually a fresh installation of nuts is configured with maven central repository so that, you already have access
+to thousands of installable artifacts.
At some point, you may need to uninstall an artifact and that's to undo the artifact installation.
+Installation will help you choose between uninstalling binaries only and keeping data/config files or remove permanently
+all of the artifact files. In all ways, uninstalling will not affect other artifacts that use the same dependencies if ever.
nuts is intended to be used either by human users or by robots and other applications. It comes with portable,
+feature rich toolset, a versatile library and an a handy parsable result.
nuts is mainly a commandline program that helps installing, uninstalling, searching, updating and running artifacts.
+To help desktop integration, nuts installs by default a set of other companion tools such as nsh (a portable
+bash-compatible implementation), nadmin (an administration tool for nuts to configure users, authorizations, repositories,
+...) and ndi (desktop integration) to help creating application shortcuts and scripts;
nsh brings the bash facilities to all environments (windows included) in a very portable manner. Besides it integrates
+well with the installed nuts version. Several common commands are ported to nsh such as cat,head, and ssh, as well core
+features like pipes, redirection and scripts.
nadmin is intended for configuring nuts workspaces, managing repositories and users. It helps also configuring
+sub commands and aliases make nuts usage even easier.
ndi, is the tool for a seamless integration in you operating system. Il mainly configures user PATH environment and
+creates scripts that point to your nuts installation on linux desktops and shortcuts to a well configured environment
+on windows.
One of the key features of nuts is the ability to support multiple isolated workspaces, each managing it's own
+repositories, applications and libraries; each defining it's sandbox security constraints.
+Thus non-root installation is made easy while it remains possible to overlap between workspaces by sharing repositories.
+Roaming is also supported, so that a workspaces can be copied/moved across machines.
Nuts can also be embedded as a library in you application. This enables you to wire classes on the fly by its network +dependency-aware classloading mechanisms. The library allows as well building solid and well integrated applications, +mainly console applications. Indeed, it comes with rich outputs that support automatic formatting to json, xml, table, +tree and plain texts. It handles as well standard File Systems layouts; XDG Base Directory Specification is implemented +for linux and MacOS. A compatible one is also implemented in Windows systems. And of course, it helps seamlessly install, +update and remove events.
In every palace you will find the wizard and the fool, the maven and the nuts; There's no
+exception in the java kingdom! If you do prefer acronyms here is another reason : nuts stands for Network
+Updatable Things Services. It should be able to facilitate things deployment and update over the
+wire where things resolve here to any piece of software depending (or not) on other piece of software.
we start by opening anew terminal (termm, konsole or whatever you prefer) then download nuts using this command :
+On linux/MacOS system we issue :
Let's check that java is installed :
Now we run nuts
We used the flags -y to auto-confirm and -z to ignore cached binaries. These flags are not required. We use them here to make installation work in all cases. +Installation may last several minutes as it will download all required dependencies, companions and tools.
You should then see this message
nuts is well installed, just restart your terminal.
Now we will install apache tomcat. So in your terminal issue :
The first two commands will install tomcat helper tool (ntomcat) that will download latest version of tomcat and configure it to 9090 port. +The last command will start tomcat. +Let's check tomcat status now
Now we will do the same with derby database. We will install it and run it.
As you can see, simple commands are all you need to download, install, configure and run tomcat or derby or any application that is deployed in the maven repository.
So please visit nuts website for more information.
nuts repository is composed of several projects that can be organized in 5 categories
nuts : These projects are the core/base of the nuts package managernuts itself. Their installation are prompted at first install of Nutsnuts Application Framework and are of common interestnuts features in your applicationCore nuts projects include nuts-builder, nuts-api, nuts-core.
nuts-builder is a meta project (parent maven pom project) that helps building all the other projects.
nuts-api is the effective "Nuts" only required dependency. It defines the bootstrap application that is responsible of loading all necessary libraries for its execution. nuts-api start to load nuts-core which is responsible of implementing all features and interfaces declared by the nuts-api library. That implementation will handle further download, version dependency etc. Such architecture is considered to force loose coupling with nuts binaries. +nuts-api is a very thin boostrapper : its size is about 300k. It can be used as a standalone application or as an embedded library.
nuts-core is the effective and standard implementation of nuts-api. nuts-core has a faster update pace than nuts-api. It focuses on performance an compliance to the Nuts specification declared by nuts-api interfaces. You are not required to add this dependency to your application if you want to embed Nuts. The library will be loaded on the wire (if not yet present in the classpath).
nuts-core is designed to have very few dependencies : gson and jansi. gson trivially is used to support json serialization : the main format used in Nuts to support configuration and descriptors. jansi is used to support terminal coloring and the "Nuts Text Coloring Format" (NTCF), a simple text format that helps creating colorful terminal applications.
Companion tools include nadmin, nsh and ndi.
+These three applications are implemented following the "nuts Application Framework" and hence are dependent on nuts-api library. They are recommended applications to install with Nuts itself, however they are not mandatory and may be ignored particularly when using nuts-api as library.
nadmin (for nuts admin)is an administration tool to the nuts workspaces. It adds support to manage users, credentials, authorizations, workspaces and repositories by providing command line support for such actions.
nsh (for nuts shell) is simply a portable POSIX bash compatible implementation. It supports all common builtin commands (ls, cd, rm, ...) and adds support to grep, ssh and scp in a seamless manner. It also supports command line, scripts (including commons constructs with if, do, case, ...) and pipes (|)
ndi (for nuts desktop integration)is simply a helper tool to support seamless integration of nuts commands in your favorite operating system and environment. ndi is responsible of creating script shortcuts to your common commands so that you can invoke tem directly from your environment. For instance it creates an "nadmin" script and configures your PATH environment to help calling the nuts admin tool instead of the common way to do so "nuts nadmin". On window system, ndi will create shortcuts and menus.
nuts comes with an array of tools out of the box you can install and play with. Here are these tools
nded for "nuts Descriptor Editor" is a small tool for creating and editing json nuts descriptor file. It is intended to be called by automation tools.
nclown is an angular web application frontend for nuts. It helps navigating, searching and installing artifacts. It is intended to be a web admin tool as well.
nserver is a standalone application that runs a small http server that will expose a workspace as a remote repository to other Nuts installations. This is the simplest way to mirror a workspace and share artifacts between networked nodes.
nwar (for nuts Web Application Archive) is a web application that exposes nserver as a war to be deployed on a more mature http server or container.
ndexer (for Indexer) is a lucene powered index for nuts. It can be shared across multiple nuts workspaces and processes.
feenoo is a small search tool. It searches for files, files contents and classes within jars. You ca search for files than contains some text or jars that contain some class, or jars of a specific version of java. +The name feenoo comes form the Tunisian dialect and means "where is it?".
file-version is a small tool that helps detecting files versions. It supports jar, war, ear, dll and exe file versions. It opens a file and looks for it's version in its meta-data.
nmysql is a companion tool to the mysql and mariadb servers. The initial actions supported are backup and restore including push/pull mechanism from/to a couple of databases for synchronization. It supports jdbc and ssh based access to remote mysql/mariadb installation.
ntomcat is a companion tool to the tomcat http server. The initial actions supported are start, stop, status, configure (http ports etc..) and deploy. It supports as well installation of several versions of Tomcat and multi domain configuration for deployments.
nderby is a companion tool to the derby database server. The initial actions supported are start, stop, status and configure. It supports as well installation of several versions of Derby.
nmvn is a companion tool to maven. It supports installations of several versions of it and running them seamlessly.
worky is a developer centered tool. The 'y' in worky refers to 'my' in the "Tunisian Dialect" and hence means "my work". Worky is the tool we - maven users - need to check if the version of project we are working on is yet to be deployed to nexus or not. So basically it checks if the version is the same, and downloads the server's version and then compares binaries to local project's to check if we have missed to update the version in our pom.xml. I know I'm not the only one having pain with jar deployments to nexus. Worky does other things as well to help me on on daily basis.
Library projects are several libraries that add nuts support in a particular environment or domain.
This is a must-have feature in your web application if deployed on Tomcat. It solves the following problem : a simple war application is surprisingly fat with too many jars (hundreds of Megas) you need to upload each time you change a single file or class in your web project. Basically all the jars included in the lib folder of the war are to be uploaded each time to the remote Tomcat server. The common solution is to use "provided" scope in maven and put your jars in Tomcat lib or ext folders. This is a bad approach if you are using a single Tomcat process for multiple applications. nuts-tomcat-classloader simply uses Nuts to download libraries when the application is deployed based on the pom.xml you provide and include them in the current web application class loader. Hence, the war becomes lighter than ever. Nuts cache mechanisms optimizes bandwidth and makes this more convenient by sharing the same jar files between applications depending on the same versions. +All you have to do is to add this library to your application and configure your pom.xml accordingly.
Basically this is the simplest way to include nserver into your web application.
This library provides helper methods to manipulate maven pom.xml and generate simple Java files while supporting nuts concepts. It is used in other tools that are meant to generate maven projects.
Other projects you may encounter in the repository are WIP projects that may be continued or discontinued. +This includes : nutsc (a native c bootstrapper) and nuts-installer (a Nuts installer tool)
Although not included in this Git repository some other tools are based on nuts and hence are installable using nuts install the-app command. Those tools are published in other repositories.
6.1 netbeans-launcher : this tool supports installation and launch of multiple netbeans instances in parallel. See Netbeans Launcher GitHub Repository
6.2 upa-box : this tool supports creation of UPA aware projects. UPA is a non structured ORM for the Java Language. See Netbeans Launcher GitHub Repository
6.3 vr-box : this tool supports creation of VR aware projects. VR is a web portal framework. See Netbeans Launcher GitHub Repository
Nuts Application is the Top Level class to be handled by nuts as rich console +application. By default NutsApplication classes : +\<ul> +\<li>have a nutsApplication=true in their descriptor file\</li> +\<li>support inheritance of all workspace options (from caller nuts +process)\</li> +\<li>enables auto-complete mode to help forecasting the next token in the +command line\</li> +\<li>enables install mode to be executed when the jar is installed in nuts +repos\</li> +\<li>enables uninstall mode to be executed when the jar is uninstaleld from +nuts repos\</li> +\<li>enables update mode to be executed when the a new version of the same jar +has been installed\</li> +\<li>have many default options enabled (such as --help, --version, --json, +--table, etc.) and thus support natively multi output channels\</li> +\</ul> +Typically a Nuts Application follows this code pattern : +\<pre> +public class MyApplication extends NutsApplication{ +public static void main(String[] args) { +// just create an instance and call runAndExit in the main method +new MyApplication().runAndExit(args); +} +// do the main staff in launch method +public void run(NutsApplicationContext appContext) { +boolean myBooleanOption=false; +NutsCommandLine cmdLine=appContext.getCommandLine() +boolean boolOption=false; +String stringOption=null; +Argument a; +while(cmdLine.hasNext()){ +if(appContext.configureFirst(cmdLine)){ +//do nothing +}else { +a=cmdLine.peek(); +switch(a.getStringKey())[ +case "-o": case "--option":{ +boolOption=cmdLine.nextBoolean().getBooleanValue(); +break; +} +case "-n": case "--name":{ +stringOption=cmdLine.nextString().getStringValue(); +break; +} +default:{ +cmdLine.unexpectedArgument(); +} +} +} +} +// test if application is running in exec mode +// (and not in autoComplete mode) +if(cmdLine.isExecMode()){ +//do the good staff here +} +} +} +\</pre> +another example of using this class is : +\<pre> +public class HLMain extends NutsApplication { +public static void main(String[] args) { +// just create an instance and call runAndExit in the main method +new HLMain().runAndExit(args); +}
\</pre>
\@since 0.5.5 +\@category Application
create application context or return null for default
return:NutsApplicationContext
this method should be overridden to perform specific business when +application is installed
this method should be overridden to perform specific business when +application is uninstalled
this method should be overridden to perform specific business when +application is updated
run application within the given context
run the application with the given arguments. If the first arguments is +in the form of --nuts-exec-mode=... the argument will be removed and the +corresponding mode is activated.
run the application with the given arguments against the given workspace +If the first arguments is in the form of --nuts-exec-mode=... the +argument will be removed and the corresponding mode is activated.
run the application and \<strong>EXIT\</strong> process
return:String
Application context that store all relevant information about application +execution mode, workspace, etc.
\@author vpc +\@since 0.5.5 +\@category Application
application class reference
application nuts id
previous version (applicable in update mode)
application version
path to the apps folder of this application
application arguments
Auto complete instance associated with the +{\@link NutsApplicationMode#AUTO_COMPLETE} mode
path to the cache files folder of this application
a new instance of command line arguments to process filled +with application\'s arguments.
path to the configuration folder of this application
return true if {\@code getAutoComplete()==null }
path to the libraries files (non applications) folder of this application
path to the log folder of this application
application execution mode
application execution mode extra arguments
path to the temporary run files (non essential sockets etc...) folder of +this application
update session
application start time in milli-seconds
path to the temporary files folder of this application
path to the variable files (aka /var in POSIX systems) folder of this +application
current workspace
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsApplicationContext
application store folder path for the given {\@code location}
return:Path
print application help to the default out ({\@code getSession().out()}) +print stream.
create new NutsCommandLine and consume it with the given processor. +This method is equivalent to the following code +\<pre> +NutsCommandLine cmdLine=getCommandLine(); +NutsArgument a; +while (cmdLine.hasNext()) { +if (!this.configureFirst(cmdLine)) { +a = cmdLine.peek(); +if(a.isOption()){ +if(!commandLineProcessor.processOption(a,cmdLine)){ +cmdLine.unexpectedArgument(); +} +}else{ +if(!commandLineProcessor.processNonOption(a,cmdLine)){ +cmdLine.unexpectedArgument(); +} +} +} +} +// test if application is running in exec mode +// (and not in autoComplete mode) +if (cmdLine.isExecMode()) { +//do the good staff here +commandLineProcessor.exec(); +} +\</pre>
This as an example of its usage +\<pre> +applicationContext.processCommandLine(new NutsCommandLineProcessor() { +HLCWithOptions hl = new HL().withOptions(); +boolean noMoreOptions=false; +@Override +public boolean processOption(NutsArgument argument, NutsCommandLine cmdLine) { +if(!noMoreOptions){ +return false; +} +switch (argument.getStringKey()) { +case "--clean": { +hl.clean(cmdLine.nextBoolean().getBooleanValue()); +return true; +} +case "-i": +case "--incremental":{ +hl.setIncremental(cmdLine.nextBoolean().getBooleanValue()); +return true; +} +case "-r": +case "--root":{ +hl.setProjectRoot(cmdLine.nextString().getStringValue()); +return true; +} +} +return false; +}
\</pre>
Application Life Cycle interface define methods to be overridden to +perform specific business for each of the predefined application execution +modes {\@link NutsApplicationMode}.
\@author vpc +\@since 0.5.5 +\@category Application
this method should be implemented to create specific ApplicationContext +implementation or return null to use default one.
return:NutsApplicationContext
this method should be implemented to perform specific business when +application is installed.
this method should be implemented to perform specific business when +application is running (default mode)
this method should be implemented to perform specific business when +application is un-installed.
this method should be implemented to perform specific business when +application is updated.
Modes Application can run with
\@since 0.5.5 +\@category Application
return:NutsApplicationMode
return:NutsApplicationMode[]
lower cased identifier.
return:String
Helper class for Nuts Applications
\@author vpc +\@since 0.5.5 +\@category Application
a thread local map used to share information between workspace +and embedded applications.
process throwables and return exit code
return:int
run application with given life cycle.
Nuts Top Class. Nuts is a Package manager for Java Applications and this class is +it\'s main class for creating and opening nuts workspaces.
\@since 0.1.0 +\@category Base
default OS family, resolvable before booting nuts workspace
current Nuts version
resolves nuts home folder.Home folder is the root for nuts folders.It +depends on folder type and store layout. For instance log folder depends +on on the underlying operating system (linux,windows,...). +Specifications: XDG Base Directory Specification +(https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html)
return:String
main method. This Main will call +{\@link Nuts#runWorkspace(java.lang.String...)} then +{\@link System#exit(int)} at completion
opens a workspace using "nuts.boot.args" and "nut.args" system +properties. "nuts.boot.args" is to be passed by nuts parent process. +"nuts.args" is an optional property that can be \'exec\' method. This +method is to be called by child processes of nuts in order to inherit +workspace configuration.
return:NutsWorkspace
open default workspace (no boot options)
return:NutsWorkspace
open a workspace. Nuts Boot arguments are passed in \<code>args\</code>
return:NutsWorkspace
open a workspace using the given options
return:NutsWorkspace
Create a {\@link NutsWorkspaceOptions} instance from string array of valid +nuts options
return:NutsWorkspaceOptions
open then run Nuts application with the provided arguments. This Main +will +\<strong>NEVER\</strong> +call {\@link System#exit(int)}.
artifact call descriptor used to define executor and installer call definitions.
\@since 0.5.4 +\@category Base
execution arguments
artifact id
execution properties
NutsArtifactCallBuilder is responsible of building instances of {\@code NutsArtifactCall} to be used +as NutsDescriptor executor or installer. +To get an instance of NutsArtifactCallBuilder you can use {\@code workspace.descriptor().callBuilder()}
\@since 0.5.4 +\@category Base
update arguments
update artifact id
update call properties map (replace all existing properties)
create an immutable instance of {\@link NutsArtifactCall} +initialized with all of this attributes.
return:NutsArtifactCall
reset this instance to default (null) values
return:NutsArtifactCallBuilder
initialize this instance from the given value
return:NutsArtifactCallBuilder
initialize this instance from the given value
return:NutsArtifactCallBuilder
user interaction mode. Some operations may require user confirmation before +performing critical operations such as overriding existing values, deleting +sensitive information ; in such cases several modes are available : either +to require user interaction (ASK mode, the default value) or force the +processing (YES mode), or ignoring the processing and continuing the next +(NO) or cancel the processing and exit with an error message (ERROR)
\@author vpc +\@since 0.5.5 +\@category Base
return:NutsConfirmationMode
return:NutsConfirmationMode[]
lower cased identifier.
return:String
Event for {\@link NutsRepositoryListener} methods. +\@author vpc +\@since 0.5.3 +\@category Base
artifact path
current repository
current session
current workspace
Definition is an \<strong>immutable\</strong> object that contains all information about a artifact identified by it\'s Id.
\@since 0.5.4 +\@category Base
return target api id (included in dependency) for the current id. +This is relevant for runtime, extension and companion ids. +For other regular ids, this returns null.
return artifact content file info (including path). +this is an \<strong>optional\</strong> property. It must be requested (see {\@link NutsSearchCommand#setContent(boolean)}) to be available.
return all or some of the transitive dependencies of the current Nuts as List +result of the search command +this is an \<strong>optional\</strong> property. +It must be requested (see {\@link NutsSearchCommand#setDependencies(boolean)} to be available.
return all of some of the transitive dependencies of the current Nuts as Tree result of the search command +this is an \<strong>optional\</strong> property. +It must be requested (see {\@link NutsSearchCommand#setDependenciesTree(boolean)} to be available.
return artifact descriptor
return artifact effective descriptor. +this is an \<strong>optional\</strong> property. +It must be requested (see {\@link NutsSearchCommand#setEffective(boolean)} to be available).
artifact id
return artifact install information.
return artifact content file path. +this is an \<strong>optional\</strong> property. It must be requested (see {\@link NutsSearchCommand#setContent(boolean)}) to be available.
name of the repository providing this id.
id of the repository providing this id.
true if requested content
true if requested content
true if requested effective descriptor
return artifact type
Compares this object with the specified definition for order. +This is equivalent to comparing subsequent ids.
return:int
execution context used in {\@link NutsExecutorComponent} and +{\@link NutsInstallerComponent}.
\@author vpc +\@since 0.5.4 +\@category Base
command arguments
command name
current working directory
command definition if any
execution environment
current session
execution type
executor descriptor
executor options
executor properties
when true, any non 0 exited command will throw an Exception
when true, the component is temporary and is not registered withing the +workspace
workspace
workspace
return:NutsWorkspace
I/O Action that help monitored compress +of one or multiple resource types. +Default implementation should handle
\@author vpc +\@since 0.5.4 +\@category Base
update format
switch log progress flag to {\@code value}.
set progress monitor. Will create a singleton progress monitor factory
set progress factory responsible of creating progress monitor
switch safe copy flag to {\@code value}
update current session
set skip root flag to {\@code value}
sources to compress
update target
add source to compress
return:NutsIOCompressAction
add source to compress
return:NutsIOCompressAction
add source to compress
return:NutsIOCompressAction
add source to compress
return:NutsIOCompressAction
add source to compress
return:NutsIOCompressAction
return format option
return:Object
switch log progress flag to to true.
return:NutsIOCompressAction
switch log progress flag to {\@code value}.
return:NutsIOCompressAction
set progress monitor. Will create a singleton progress monitor factory
return:NutsIOCompressAction
set progress factory responsible of creating progress monitor
return:NutsIOCompressAction
run this Compress action
return:NutsIOCompressAction
arm safe copy flag
return:NutsIOCompressAction
switch safe copy flag to {\@code value}
return:NutsIOCompressAction
update format option
return:NutsIOCompressAction
set skip root flag to {\@code true}
return:NutsIOCompressAction
set skip root flag to {\@code value}
return:NutsIOCompressAction
update target
return:NutsIOCompressAction
update target
return:NutsIOCompressAction
update target
return:NutsIOCompressAction
update target
return:NutsIOCompressAction
update target
return:NutsIOCompressAction
Mutable IdLocation class that helps creating instance of immutable {\@link NutsIdLocation}. +Instances of {\@link NutsIdLocation} are used in {\@link NutsDescriptor} (see {\@link NutsDescriptor#getLocations()})
\@category Base
update location classifier
update location region
update location url
create new instance of {\@link NutsIdLocation} initialized with this builder values.
return:NutsIdLocation
update location classifier
return:NutsIdLocationBuilder
clear this instance (set null/default all properties)
return:NutsIdLocationBuilder
update location region
return:NutsIdLocationBuilder
update all attributes, copy from {\@code value} instance
return:NutsIdLocationBuilder
update all attributes, copy from {\@code value} instance
return:NutsIdLocationBuilder
update location url
return:NutsIdLocationBuilder
Artifacts are organized according to {\@code NutsIdType} to reflect how the artifact +should be managed by the workspace. +This information is available in {\@link NutsDefinition} +\@category Base
return:NutsIdType
return:NutsIdType[]
Classes implementations of {\@code NutsIndexStore} handle +indexing of repositories to enable faster search. +\@author vpc +\@since 0.5.4 +\@category Base
enable of disable ot index
return true if the current repository is registered
enable index
return:NutsIndexStore
enable of disable ot index
return:NutsIndexStore
invalidate the artifact from the index
return:NutsIndexStore
invalidate the artifact from the index and re-index it
return:NutsIndexStore
search all artifacts matching the given filter
return:Iterator
search all versions of the given artifact
return:Iterator
subscribe the current repository so the indexing +is processed.
return:NutsIndexStore
unsubscribe the current repository so that the indexing +is disabled and the index is removed.
return:NutsIndexStore
Index Store Factory responsible of creating stores for a given repository +\@author vpc +\@since 0.5.4 +\@category Base
create a new index store implementation or null if not supported
return:NutsIndexStore
Interface to enable marking system streams. When creating new processes nuts +will dereference NutsInputStreamTransparentAdapter to check if the +InputStream i a system io. In that case nuts will "inherit" input stream
\@since 0.5.4 +\@category Base
de-referenced stream
return:InputStream
Command for installing artifacts +\@author vpc +\@since 0.5.4 +\@category Base +\@category Commands
return all arguments to pass to the install command
if true update companions
set default version flag. when true, the installed version will be defined as default
return all ids to install
if true reinstall installed artifacts
execute installation and return result.
update session
add argument to pass to the install command
return:NutsInstallCommand
add arguments to pass to the install command
return:NutsInstallCommand
add arguments to pass to the install command
return:NutsInstallCommand
add artifact id to install
return:NutsInstallCommand
add artifact id to install
return:NutsInstallCommand
add artifact ids to install
return:NutsInstallCommand
add artifact ids to install
return:NutsInstallCommand
add argument to pass to the install command
return:NutsInstallCommand
add arguments to pass to the install command
return:NutsInstallCommand
add arguments to pass to the install command
return:NutsInstallCommand
clear all arguments to pass to the install command
return:NutsInstallCommand
clear ids to install
return:NutsInstallCommand
update companions
return:NutsInstallCommand
if true update companions
return:NutsInstallCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsInstallCommand
copy session
return:NutsInstallCommand
set default version flag. the installed version will be defined as default.
return:NutsInstallCommand
set default version flag. when true, the installed version will be defined as default
return:NutsInstallCommand
add artifact id to install
return:NutsInstallCommand
add artifact id to install
return:NutsInstallCommand
add artifact ids to install
return:NutsInstallCommand
add artifact ids to install
return:NutsInstallCommand
reinstall installed artifacts
return:NutsInstallCommand
if true reinstall installed artifacts
return:NutsInstallCommand
remove artifact id to install
return:NutsInstallCommand
remove artifact id to install
return:NutsInstallCommand
execute the command and return this instance
return:NutsInstallCommand
Event describing installation of an artifact +\@author vpc +\@since 0.5.6 +\@category Base
return artifact definition
return true if installation was forced
return current session
vcurrent workspace
Information about installed artifact +\@author vpc +\@since 0.5.5 +\@category Base
true when the installed artifact is default version
installation date
installation date
installation formation path.
return install status
return the user responsible of the installation
return true if installed primary or dependency
true if the installation just occurred in the very last operation
true if the re-installation just occurred in the very last operation
Package installation status +\@category Base
return:NutsInstallStatus
return:NutsInstallStatus[]
lower cased identifier.
return:String
Anchor interface for all Nuts Listeners. +\@author vpc +\@since 0.5.5 +\@category Base
Map Listener to catch updates
\@param \<K> key type +\@param \<V> value type +\@since 0.2.0 +\@category Base
Invoked when item added
Invoked when item removed
Invoked when item updated
Supported Operating System Families +\@author vpc +\@since 0.5.4 +\@category Base
return:NutsOsFamily
return:NutsOsFamily[]
lower cased identifier.
return:String
System Process Information +\@category Base
Process command line
Process Name. +This should represent Fully Qualified Java Main Class Name for java processes.
Process Id in string representation
Process Title / Window Title if available
Progress event +\@author vpc +\@since 0.5.8 +\@category Base
progress current value
error or null
when true, max value is unknown, and the progress is indeterminate
progress max value or -1 if intermediate
event message
progress time from the starting of the last mark point.
progress value from the last mark point. +Mark point occurs when {\@link NutsProgressMonitor#onProgress(NutsProgressEvent)} return false.
progress percentage ([0..100])
Nuts Session
progress source object
progress time from the starting of the progress.
NutsProgressFactory is responsible of creating instances of {\@link NutsProgressMonitor} +\@author vpc +\@since 0.5.8 +\@category Base
create a new instance of {\@link NutsProgressMonitor}
return:NutsProgressMonitor
Monitor handles events from copy, compress and delete actions +\@author vpc +\@since 0.5.8 +\@category Base
called when the action terminates
called when the action does a step forward and return +true if the progress was handled of false otherwise.
return:boolean
called when the action starts
Question is helpful object that permits user interaction by reading a typed object from +standard input or an equivalent input system. +\@param \<T> value type returned by this question object +\@author vpc +\@since 0.5.4 +\@category Base
equivalent to (Boolean) getValue() as type dereferencing may cause some +troubles
return:NutsQuestion
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
return:NutsQuestion
\@author vpc +\@since 0.5.4 +\@category Base
return:Object
\@author vpc +\@since 0.5.4 +\@category Base
return:Object
Nuts repository manages a set of packages
\@since 0.5.4 +\@category Base
return repository name. +equivalent to config().name()
return parent repository or null
Repository Listeners
return repository type
return array of registered user properties listeners
return repository unique identifier
return parent workspace
add repository listener
add listener to user properties
return repository configuration manager
return:NutsRepositoryConfigManager
create deploy command
return:NutsDeployRepositoryCommand
create fetchContent command
return:NutsFetchContentRepositoryCommand
create fetchDescriptor command
return:NutsFetchDescriptorRepositoryCommand
return repository name. +equivalent to config().name()
return:String
return parent repository or null
return:NutsRepository
create push command
return:NutsPushRepositoryCommand
remove repository listener
remove listener from user properties
return repository type
return:String
create search command
return:NutsSearchRepositoryCommand
create searchVersions command
return:NutsSearchVersionsRepositoryCommand
return repository security manager
return:NutsRepositorySecurityManager
create undeploy command
return:NutsRepositoryUndeployCommand
create update statistics command
return:NutsUpdateRepositoryStatisticsCommand
return mutable instance of user properties
return:Map
return repository unique identifier
return:String
return parent workspace
return:NutsWorkspace
Created by vpc on 1/5/17.
\@since 0.5.4 +\@category Base
return:boolean
Find Result items from find command
\@see NutsSearchCommand#getResultIds() +\@author vpc +\@param \<T> Result Type +\@since 0.5.4 +\@category Base
return elements count of this result.
consumes the result and returns the number of elements consumed. Calling +this method twice will result in unexpected behavior (may return 0 as the +result is already consumed or throw an Exception)
return:long
return the first value or null if none found.
Calling this method twice will result in unexpected behavior (may return +an incorrect value such as null as the result is already consumed or +throw an Exception)
return:Object
return result as a java.util.List .
consumes the result and returns a list Calling this method twice will +result in unexpected behavior (may return an empty list as the result is +already consumed or throw an Exception)
return:List
return the first value or NutsNotFoundException if not found.
Calling this method twice will result in unexpected behavior (may return +an incorrect value such as null as the result is already consumed or +throw an Exception)
return:Object
return the first value while checking that there are no more elements.
Calling this method twice will result in unexpected behavior (may return +an incorrect value such as null as the result is already consumed or +throw an Exception)
return:Object
return result as a java.util.stream.Stream .
Calling this method twice will result in unexpected behavior (may return +0 as the result is already consumed or throw an Exception)
return:Stream
Search id defines a uniform interface to ids, versions and descriptors +\@author vpc +\@since 0.5.4 +\@category Base
return descriptor
return:NutsDescriptor
return id
return:NutsId
return version
return:NutsVersion
SearchId Filter. +\@author vpc +\@since 0.5.4 +\@category Base
true if search id is accepted
return:boolean
session is context defining common command options and parameters.
\@author vpc +\@since 0.5.4 +\@category Base
equivalent to {\@code setConfirm(enable?ASK:null)}
use cache
set confirm mode.
change fetch strategy
change force flag value. some operations may require user confirmation +before performing critical operations such as overriding existing values, +deleting sensitive information ; in such cases, arming force flag will +provide an implicit confirmation.
use index
set iterable output format
true if iterable format is armed. equivalent to +{\@code getIterableFormat()!=null}
return iterable output
true if iterable format and trace flag are armed. equivalent to {\@code isTrace() +&& isIterableOut()}
return all registered listeners.
change no flag value. some operations may require user confirmation +before performing critical operations such as overriding existing values, +deleting sensitive information ; in such cases, arming no flag will +provide an implicit negative confirmation.
set output format
set output format options (clear and add)
true if NON iterable and plain format are armed.
true if non iterable and plain formats along with trace flag are armed. +equivalent to {\@code isTrace() +&& !isIterableOut() +&& getOutputFormat() == NutsOutputFormat.PLAIN}
change progress options
add session properties
true if NON iterable and NON plain formats are armed. equivalent to {\@code !isIterableOut() +&& getOutputFormat() != NutsOutputFormat.PLAIN}
true if NON iterable and NON plain formats along with trace flag are +armed. equivalent to {\@code isTrace() +&& !isIterableOut() +&& getOutputFormat() == NutsOutputFormat.PLAIN}
set session terminal
change trace flag value. When true, operations are invited to print to +output stream information about processing. Output may be in different +formats according to {\@link #getOutputFormat()} and +{\@link #getIterableFormat()}
consider transitive repositories
current workspace
change YES flag value. some operations may require user confirmation +before performing critical operations such as overriding existing values, +deleting sensitive information ; in such cases, arming yes flag will +provide an implicit confirmation.
add session listener. supported listeners are instances of: +\<ul> +\<li>{\@link NutsWorkspaceListener}\</li> +\<li>{\@link NutsInstallListener}\</li> +\<li>{\@link NutsMapListener}\</li> +\<li>{\@link NutsRepositoryListener}\</li> +\</ul>
return:NutsSession
add output format options
return:NutsSession
equivalent to {\@code setAsk(true)}
return:NutsSession
set confirm mode.
return:NutsSession
return new instance copy of {\@code this} session
return:NutsSession
copy into this instance from the given value
return:NutsSession
current error stream
return:PrintStream
change fetch strategy to ANYWHERE
return:NutsSession
change fetch strategy to OFFLINE
return:NutsSession
change fetch strategy to ONLINE
return:NutsSession
change fetch strategy to REMOTE
return:NutsSession
change fetch strategy
return:NutsSession
This is a helper method to create and Object format initialized with this +session instance and the given object to print. +{\@code thisSession.getWorkspace().object().setSession(thisSession).value(any)} +\<p> +Using this method is recommended to print objects to default format (json, xml,...)
return:NutsObjectFormat
return registered listeners for the given type. Supported types are : +\<ul> +\<li>{\@link NutsWorkspaceListener}\</li> +\<li>{\@link NutsInstallListener}\</li> +\<li>{\@link NutsMapListener}\</li> +\<li>{\@link NutsRepositoryListener}\</li> +\</ul>
return:NutsListener[]
return current Output Format or {\@code defaultValue} if null
return:NutsOutputFormat
return property value or null
return:Object
set json output format
return:NutsSession
equivalent to {\@code setNo(true)}
return:NutsSession
equivalent to {\@code setNo(enable)}
return:NutsSession
current output stream
return:PrintStream
set plain text (default) output format
return:NutsSession
set properties output format
return:NutsSession
remove session listener. supported listeners are instances of: +\<ul> +\<li>{\@link NutsWorkspaceListener}\</li> +\<li>{\@link NutsInstallListener}\</li> +\<li>{\@link NutsMapListener}\</li> +\<li>{\@link NutsRepositoryListener}\</li> +\</ul>
return:NutsSession
set session property
return:NutsSession
equivalent to {\@code setTrace(false)}
return:NutsSession
set table output format
return:NutsSession
current terminal
return:NutsSessionTerminal
set tree output format
return:NutsSession
current workspace
return:NutsWorkspace
set xml output format
return:NutsSession
equivalent to {\@code setYes(true)}
return:NutsSession
equivalent to {\@code setYes(enable)}
return:NutsSession
Created by vpc on 2/20/17.
\@since 0.5.4 +\@category Base
return:NutsSessionTerminal
\@author vpc +\@since 0.5.4 +\@category Base
return:NutsStoreLocation
return:NutsStoreLocation[]
lower cased identifier.
return:String
\@since 0.5.4 +\@category Base
return:NutsStoreLocationStrategy
return:NutsStoreLocationStrategy[]
lower cased identifier.
return:String
\@author vpc +\@since 0.5.4 +\@category Base
return:NutsTerminalMode
return:NutsTerminalMode[]
lower cased identifier.
return:String
\@author vpc +\@since 0.5.5 +\@category Base
return:boolean
return:boolean
return:boolean
Created by vpc on 2/1/17.
\@since 0.5.4 +\@category Base
return:boolean
Created by vpc on 1/5/17.
\@since 0.5.4 +\@category Base
Workspace name
Workspace identifier, guaranteed to be unique cross machines
return:NutsCommandLineFormat
return:NutsWorkspaceConfigManager
return:NutsSession
create dependency format instance
return:NutsDependencyFormat
return:NutsDeployCommand
create descriptor format instance
return:NutsDescriptorFormat
create element format instance
return:NutsElementFormat
return:NutsExecCommand
return:NutsWorkspaceExtensionManager
return:NutsFetchCommand
create id format instance
return:NutsIdFormat
create info format instance
return:NutsInfoFormat
return:NutsInstallCommand
return:NutsIOManager
create iterable format instance
return:NutsIterableOutput
create json format instance
return:NutsJsonFormat
return:NutsLogManager
equivalent to {\@link #getName()}
return:String
create object format instance
return:NutsObjectFormat
create properties format instance
return:NutsPropertiesFormat
return:NutsPushCommand
return:NutsSearchCommand
return:NutsWorkspaceSecurityManager
create string format instance
return:NutsStringFormat
create table format instance
return:NutsTableFormat
create tree format instance
return:NutsTreeFormat
return:NutsUndeployCommand
return:NutsUninstallCommand
return:NutsUpdateCommand
return:NutsUpdateStatisticsCommand
return:Map
equivalent to {\@link #getUuid()}
return:String
create version format instance
return:NutsVersionFormat
create xml format instance
return:NutsXmlFormat
Command Line Argument
\@author vpc +\@since 0.5.5 +\@category Command Line
return new instance (never null) of the key part of the argument. The key +does not include neither ! nor // or = argument parts as they are parsed +separately. Here example of getArgumentKey result of some arguments +\<ul> +\<li>Argument("key").getArgumentKey() ==> Argument("key") \</li> +\<li>Argument("key=value").getArgumentKey() ==> Argument("key") \</li> +\<li>Argument("--key=value").getArgumentKey() ==> Argument("--key") +\</li> +\<li>Argument("--!key=value").getArgumentKey() ==> Argument("--key") +\</li> +\<li>Argument("--!//key=value").getArgumentKey() ==> Argument("--key") +\</li> +\</ul>
return option key part excluding prefix (\'-\' and \'--\')
return new instance (never null) of the value part of the argument (after +=). However Argument\'s value may be null ( +{\@code getArgumentValue().getString() == null}). Here are some examples of +getArgumentValue() result for some common arguments +\<ul> +\<li>Argument("key").getArgumentValue() ==> Argument(null) \</li> +\<li>Argument("key=value").getArgumentValue() ==> Argument("value") +\</li> +\<li>Argument("key=").getArgumentValue() ==> Argument("") \</li> +\<li>Argument("--key=value").getArgumentValue() ==> Argument("value") +\</li> +\<li>Argument("--!key=value").getArgumentValue() ==> Argument("value") +\</li> +\<li>Argument("--!//key=value").getArgumentValue() ==> +Argument("value") \</li> +\</ul>
test if the argument is valid boolean. a valid boolean mush match one of +the following regular expressions : +"true|enable|enabled|yes|always|y|on|ok|t" : will be evaluated as true +boolean. "false|disable|disabled|no|none|never|n|off|ko" : will be +evaluated as false boolean. In both cases, this method returns true. +Otherwise, it will return false.
parse argument\'s value as boolean equivalent to +{\@code getArgumentValue().getBoolean()}
parse number and return double.
false if option is in one of the following forms : +\<ul> +\<li>-//name\</li> +\<li>--//name\</li> +\</ul> +where name is any valid identifier
parse number and return integer.
true if the argument is in the form key=value
return query value separator
parse number and return long.
true if option is in one of the following forms : +\<ul> +\<li>-!name[=...]\</li> +\<li>--!name[=...]\</li> +\<li>!name[=...]\</li> +\</ul> +where name is any valid identifier
true if the argument do not start with \'-\' or \'+\' or is blank. this is +equivalent to {\@code !isOption()}.
true if the argument starts with \'-\' or \'+\'
string representation of the argument or null
return key part (never null) of the argument. The key does not include +neither ! nor // or = argument parts as they are parsed separately. Here +are some examples of getStringKey() result for some common arguments +\<ul> +\<li>Argument("key").getArgumentKey() ==> "key" \</li> +\<li>Argument("key=value").getArgumentKey() ==> "key" \</li> +\<li>Argument("--key=value").getArgumentKey() ==> "--key" +\</li> +\<li>Argument("--!key=value").getArgumentKey() ==> "--key" +\</li> +\<li>Argument("--!//key=value").getArgumentKey() ==> "--key" +\</li> +\<li>Argument("--//!key=value").getArgumentKey() ==> "--key" +\</li> +\</ul> +equivalent to {\@code getArgumentKey().getString()}
return option key part excluding prefix (\'-\' and \'--\')
return option prefix part (\'-\' and \'--\')
equivalent to {\@code getArgumentValue().getString()}
return boolean value if the current argument can be parsed as valid +boolean of defaultValue if not
"true|enable|enabled|yes|always|y|on|ok|t" are considered \'true\'. +"false|disable|disabled|no|none|never|n|off|ko" are considered \'false\'.
return:Boolean
parse number and return double or {\@code defaultValue} if not parsable.
return:double
parse number and return integer or {\@code defaultValue} if not parsable.
return:int
parse number and return long or {\@code defaultValue} if not parsable.
return:long
string representation of the argument or the given defaultValue
return:String
equivalent to {\@code getArgumentValue().getString(value)}
return:String
Throw an exception if the argument is null
return:NutsArgument
Argument Candidate used in Auto Complete.
Created by vpc on 3/7/17.
\@since 0.5.5 +\@category Command Line
human display
argument value
Non Option Argument specification
\@author vpc +\@since 0.5.5 +\@category Command Line
argument name
argument candidate values
return:List
Argument parse Type
\@author vpc +\@since 0.5.5 +\@category Command Line
return:NutsArgumentType
return:NutsArgumentType[]
lower cased identifier.
return:String
Auto Complete Helper class used to collect argument candidates +\@author vpc +\@since 0.5.5 +\@category Command Line
current candidates
candidates index
command line string
command line arguments
add candidate
return:Object
Base (Abstract) implementation of NutsCommandAutoComplete +\@author vpc +\@since 0.5.5 +\@category Command Line
possible candidates
add candidate
simple add candidates implementation
return:NutsArgumentCandidate
return:Object
Command execution options +\@author vpc +\@since 0.5.4 +\@category Command Line
execution directory
execution environment variables
execution type
execution options
when fail fast,non zero exit value will raise NutsExecutionException
return:boolean
return:int
return:String
Simple Command line parser implementation. The command line supports +arguments in the following forms : +\<ul> +\<li> non option arguments : any argument that does not start with \'-\'\</li>
\<li> +long option arguments : any argument that starts with a single \'--\' in the +form of +\<pre>--[//][!]?[^=][=.]\</pre> +\<ul> +\<li>// means disabling the option\</li> +\<li>! means switching (to \'false\') the option\'s value\</li> +\<li>the string before the \'=\' is the option\'s key\</li> +\<li>the string after the \'=\' is the option\'s value\</li> +\</ul> +Examples : +\<ul> +\<li>--!enable : option \'enable\' with \'false\' value\</li> +\<li>--enable=yes : option \'enable\' with \'yes\' value\</li> +\<li>--!enable=yes : invalid option (no error will be thrown but the result +is undefined)\</li> +\</ul> +\</li> +\<li> +simple option arguments : any argument that starts with a single \'-\' in the +form of +\<pre>-[//][!]?[a-z][=.*]\</pre> This is actually very similar to long options +\<ul> +\<li>-!enable (with expandSimpleOptions=false) : option \'enable\' with \'false\' +value\</li> +\<li>--enable=yes : option \'enable\' with \'yes\' value\</li> +\<li>--!enable=yes : invalid option (no error will be thrown but the result +is undefined)\</li> +\</ul>
\</li> +\<li> +condensed simple option arguments : any argument that starts with a single \'-\' in the +form of +\<pre>-[//]([!]?[a-z])+[=.*]\</pre> This is actually very similar to long options +and is parsable when expandSimpleOptions=true. When activating expandSimpleOptions, multi +characters key will be expanded as multiple separate simple options Examples +: +\<ul> +\<li>-!enable (with expandSimpleOptions=false) : option \'enable\' with \'false\' +value\</li> +\<li>--enable=yes : option \'enable\' with \'yes\' value\</li> +\<li>--!enable=yes : invalid option (no error will be thrown but the result +is undefined)\</li> +\</ul>
\</li>
\<li>long option arguments : any argument that starts with a \'--\' \</li> +\</ul> +option may start with \'!\' to switch armed flags expandSimpleOptions : when +activated
\@author vpc +\@since 0.5.5 +\@category Command Line
reset this instance with the given arguments
set autocomplete instance
true if auto complete instance is registered (is not null)
set command name that will be used as an extra info in thrown exceptions
true if no more arguments are available
true if auto complete instance is not registered (is null)
enable or disable simple option expansion
list of registered simple options
current word index
true if arguments start with the given suite.
return:boolean
true if arguments start at index {\@code index} with the given suite.
return:boolean
return true if any argument is equal to the given name
return:boolean
find first argument with argument key name
return:NutsArgument
return argument at given index
return:NutsArgument
true if there still at least one argument to consume
return:boolean
first argument index (or -1 if not found) with value {\@code name}
return:int
true if the argument and index exists and is non option
return:boolean
true if the argument and index exists and is option
return:boolean
test if the option is a registered simple option +This method helps considering \'-version\' as a single simple options when +{\@code isExpandSimpleOptions()==true}
return:boolean
number of arguments available to retrieve
return:int
consume (remove) the first argument and return it return null if not +argument is left
return:NutsArgument
consume (remove) the first argument and return it while adding a hint to +Auto Complete about expected argument candidates return null if not +argument is left
return:NutsArgument
next argument with any value type (may having not a value). equivalent to +{\@code next(NutsArgumentType.ANY,names)}
return:NutsArgument
next argument with any value type (may having not a value).
return:NutsArgument
next argument with boolean value equivalent to +next(NutsArgumentType.STRING,names)
return:NutsArgument
next argument if it exists and it is a non option. Return null in all +other cases.
return:NutsArgument
next argument if it exists and it is a non option. Return null in all +other cases.
return:NutsArgument
next argument if it exists and it is a non option. Throw an error in all +other cases.
return:NutsArgument
next argument with string value. equivalent to +next(NutsArgumentType.STRING,names)
return:NutsArgument
reset this instance with the given parsed arguments
return:NutsCommandLine
the first argument to consume without removing/consuming it or null if +not argument is left
return:NutsArgument
push back argument so that it will be first to be retrieved (using next methods)
return:NutsCommandLine
register {\@code options} as simple (with simple \'-\') option. +This method helps considering \'-version\' as a single simple options when +{\@code isExpandSimpleOptions()==true}
return:NutsCommandLine
throw exception if command line is empty or the first word is an option
return:NutsCommandLine
throw exception if command line is empty
return:NutsCommandLine
throw exception if command line is empty
return:NutsCommandLine
skip next argument
return:int
consume {\@code count} words and return how much it was able to consume
return:int
consume all words and return consumed count
return:int
returns un-parsed (or partially parsed) available arguments
return:String[]
throw exception if command line is not empty
return:NutsCommandLine
throw exception if command line is not empty
return:NutsCommandLine
unregister {\@code options} as simple (with simple \'-\') option. +This method helps considering \'-version\' as a single simple options when +{\@code isExpandSimpleOptions()==true}
return:NutsCommandLine
Simple Command line Format
\@author vpc +\@since 0.5.7 +\@category Command Line
update session
set command line from parsed string
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsCommandLineFormat
return new Command line instance
return:NutsCommandLine
return new Command line instance
return:NutsCommandLine
create new argument
return:NutsArgument
create argument candidate
return:NutsArgumentCandidate
create argument candidate
return:NutsArgumentCandidate
create argument name
return:NutsArgumentName
create argument name
return:NutsArgumentName
return new Command line instance
return:NutsCommandLine
\@category Command Line
execute options, called after all options was processed and +cmdLine.isExecMode() return true.
process the given non option argument that was peeked from the command line. +Implementations \<strong>MUST\</strong> call one of +the "next" methods to
return:boolean
process the given option argument that was peeked from the command line. +Implementations \<strong>MUST\</strong> call one of +the "next" methods to
return:boolean
Configurable interface define a extensible way to configure nuts commands +and objects using simple argument line options. +\@author vpc +\@since 0.5.5 +\@category Command Line
configure the current command with the given arguments.
return:Object
configure the current command with the given arguments.
return:boolean
ask {\@code this} instance to configure with the very first argument of +{\@code commandLine}. If the first argument is not supported, return +{\@code false} and consume (skip/read) the argument. If the argument +required one or more parameters, these arguments are also consumed and +finally return {\@code true}
return:boolean
Nuts deploy command +\@author vpc +\@since 0.5.4 +\@category Commands
set content
set descriptor sha1 hash
set descriptor
return ids to deploy from source repository
set target repository to deploy to
run command (if not yet run) and return result
update session
set content sha1 hash
set source repository to deploy from the given ids
set target repository to deploy to
add id to deploy from source repository
return:NutsDeployCommand
add id to deploy from source repository
return:NutsDeployCommand
add ids to deploy from source repository
return:NutsDeployCommand
add ids to deploy from source repository
return:NutsDeployCommand
reset ids list to deploy
return:NutsDeployCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsDeployCommand
copy session
return:NutsDeployCommand
set source repository to deploy from the given ids
return:NutsDeployCommand
remove id to deploy from source repository
return:NutsDeployCommand
remove id to deploy from source repository
return:NutsDeployCommand
execute the command and return this instance
return:NutsDeployCommand
set target repository to deploy to
return:NutsDeployCommand
Execute command. +This class helps executing all types of executables : internal, external, alias and system
\@author vpc +\@since 0.5.4 +\@category Commands
set command artifact definition. +The definition is expected to include content, dependencies, effective descriptor and install information.
set execution directory
if true set dry execution
clear existing env and set new env
set new command error stream (standard error destination)
return grabbed error after command execution
set execution type
return executor options
when the execution returns a non zero result, an exception is +thrown.Particularly, if grabOutputString is used, error exception will +state the output message
set new command input stream (standard input source)
set new command output stream (standard output destination)
return grabbed output after command execution
if true redirect standard error is redirected to standard output
return result value. if not yet executed, will execute first.
return result exception or null
update session
append command arguments
return:NutsExecCommand
append command arguments
return:NutsExecCommand
merge env properties
return:NutsExecCommand
append executor options
return:NutsExecCommand
append executor options
return:NutsExecCommand
append executor options
return:NutsExecCommand
clear command
return:NutsExecCommand
clear env
return:NutsExecCommand
clear executor options
return:NutsExecCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsExecCommand
create a copy of {\@code this} instance
return:NutsExecCommand
copy all field from the given command into {\@code this} instance
return:NutsExecCommand
copy session
return:NutsExecCommand
set embedded execution type
return:NutsExecCommand
return:NutsExecCommandFormat
grab to memory standard error
return:NutsExecCommand
grab to memory standard output
return:NutsExecCommand
set root command execution type
return:NutsExecCommand
execute the command and return this instance
return:NutsExecCommand
set or unset env property. +the property is unset if the value is null.
return:NutsExecCommand
set spawn execution type
return:NutsExecCommand
set user command execution type
return:NutsExecCommand
return executable information
return:NutsExecutableInformation
Command execution type. +\@author vpc +\@since 0.5.4 +\@category Commands
return:NutsExecutionType
return:NutsExecutionType[]
lower cased identifier.
return:String
Fetch command class helps fetching/retrieving a artifact with all of its +files.
\@author vpc +\@since 0.5.4 +\@category Commands
enable/disable retrieval from cache
enable/disable retrieval of content info
enable/disable dependencies list retrieval
enable/disable dependencies tree retrieval
enable/disable effective descriptor evaluation
set armed (or disarmed) fail safe mode. if true, null replaces +NutsNotFoundException.
set fetch strategy.
set id to fetch.
set index filter.if null index is removed. if false do not consider index. +if true, consider index.
search for installed/non installed packages
set locating where to fetch the artifact. If the location is a folder, a +new name will be generated.
set option filter. if null filter is removed. if false only non optional +will be retrieved. if true, only optional will be retrieved.
return result as content
return result as content hash string
return result as artifact definition
return result as descriptor
return result as descriptor hash string
return result as id
return result as content path
dependencies scope filters
update session
set or unset transitive mode
add repository filter
return:NutsFetchCommand
add repository filter
return:NutsFetchCommand
add repository filter
return:NutsFetchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean) +} and {\@link #setDependenciesTree(boolean)}
return:NutsFetchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean) +} and {\@link #setDependenciesTree(boolean)}
return:NutsFetchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean) +} and {\@link #setDependenciesTree(boolean)}
return:NutsFetchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean)} +and {\@link #setDependenciesTree(boolean)}
return:NutsFetchCommand
remove all repository filters
return:NutsFetchCommand
remove all dependency scope filters.
return:NutsFetchCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) +} +to help return a more specific return type;
return:NutsFetchCommand
create copy (new instance) of {\@code this} command
return:NutsFetchCommand
copy into {\@code this} from {\@code other} fetch command
return:NutsFetchCommand
copy session
return:NutsFetchCommand
search for non installed packages
return:NutsFetchCommand
search for installed/non installed packages
return:NutsFetchCommand
search for non installed packages
return:NutsFetchCommand
remove repository filter
return:NutsFetchCommand
remove dependency scope filter.
return:NutsFetchCommand
remove dependency scope filter.
return:NutsFetchCommand
execute the command and return this instance
return:NutsFetchCommand
all artifacts (local and remote). If local result found will any way +fetch remote.
return:NutsFetchCommand
unset location to store to fetched id and fall back to default location.
return:NutsFetchCommand
set id to fetch to nuts-api (api artifact)
return:NutsFetchCommand
set id to fetch to nuts-core (runtime artifact)
return:NutsFetchCommand
local only (installed or not)
return:NutsFetchCommand
local or remote. If local result found will not fetch remote.
return:NutsFetchCommand
remote only
return:NutsFetchCommand
fetch mode defines if the artifact should be looked for withing the "installed" meta repository, "local" (offline) +machine repositories or over the wire (remote repositories).
\<p> +"installed" artifacts are stored in a pseudo-repository called "installed" which include all installed +(using command install) artifacts. Effective storage may (should?) remain in a local repository though. +Actually pseudo-repository "installed" manages references to these storages. +\</p> +\<p> +local repositories include all local folder based repositories. Semantically they should define machine/node based +storage that is independent from LAN/WAN/Cloud networks. A local database based repository may be considered as local +though not recommended as the server may be down. +Il all ways, local repositories are considered fast according to fetch/deploy commands. +\</p> +\<p> +remote repositories include all non local repositories which may present slow access and connectivity issues. +Typically this include server based repositories (http, ...). +\</p> +\<p> +It is important to say that a repository may serve both local and remote artifacts as usually remote repositories +enable cache support; in which case, if the artifact si cached, it will be accessed locally. +\</p> +\@since 0.5.4 +\@category Commands
return:NutsFetchMode
return:NutsFetchMode[]
lower cased identifier.
return:String
Fetch strategy defines modes (see {\@link NutsFetchMode}) to use when searching for an artifact. +\@author vpc +\@since 0.5.4 +\@category Commands
return:NutsFetchStrategy
return:NutsFetchStrategy[]
if true, do not consider next Fetch mode if the latter gives at least one result.
lower cased identifier.
return:String
ordered fetch modes iterator
return:Iterator
ordered fetch modes
return:NutsFetchMode[]
Push command +\@author vpc +\@since 0.5.4 +\@category Commands
return all arguments to pass to the push command
return ids to push for
return locked ids to prevent them to be updated or the force other ids to use them (the installed version).
local only (installed or not)
repository to push from
update session
add argument to pass to the push command
return:NutsPushCommand
add arguments to pass to the push command
return:NutsPushCommand
add arguments to pass to the push command
return:NutsPushCommand
add id to push.
return:NutsPushCommand
add id to push.
return:NutsPushCommand
add ids to push.
return:NutsPushCommand
add ids to push.
return:NutsPushCommand
add locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
add locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
add locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
define locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
add argument to pass to the push command
return:NutsPushCommand
add arguments to pass to the push command
return:NutsPushCommand
add arguments to pass to the push command
return:NutsPushCommand
clear all arguments to pass to the push command
return:NutsPushCommand
reset ids to push for
return:NutsPushCommand
reset locked ids
return:NutsPushCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsPushCommand
copy session
return:NutsPushCommand
add id to push.
return:NutsPushCommand
add id to push.
return:NutsPushCommand
add ids to push.
return:NutsPushCommand
add ids to push.
return:NutsPushCommand
add locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
add locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
define locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
define locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
local only (installed or not)
return:NutsPushCommand
local only (installed or not)
return:NutsPushCommand
remove id to push.
return:NutsPushCommand
remove id to push.
return:NutsPushCommand
remove locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
remove locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsPushCommand
repository to push from
return:NutsPushCommand
execute the command and return this instance
return:NutsPushCommand
\@author vpc +\@since 0.5.4 +\@category Commands
return:boolean
return:NutsRemoveOptions
return:NutsRemoveOptions
return:int
return:NutsRemoveOptions
return:NutsRemoveOptions
return:String
Search command class helps searching multiple artifacts with all of their +files.
\@author vpc +\@since 0.5.4 +\@category Commands
set nuts app filter. if true nuts app (implementing NutsApplication) only +are retrieved.
include base package when searching for inlined dependencies
enable/disable retrieval from cache
set companions filter. if true companions only are retrieved.
result comparator
enable/disable retrieval of content info
default version only filter
enable/disable dependencies list retrieval
enable/disable dependencies tree retrieval
define dependency filter. applicable when using {\@link #setInlineDependencies(boolean)}
define descriptor filter.
skip duplicates
enable/disable effective descriptor evaluation
set app filter. if true non lib (app) only are retrieved.
set extensions filter. if true extensions only are retrieved.
set armed (or disarmed) fail safe mode. if true, null replaces +NutsNotFoundException.
set fetch strategy.
define id filter.
return ids to search for
set index filter.if null index is removed. if false do not consider +index. if true, consider index.
enable/disable inlined dependencies list retrieval
search for non packages with the given {\@code installStatus}
if true search must return only latest versions for each artifact id
set lib filter. if true lib (non app) only are retrieved.
set locating where to fetch the artifact. If the location is a folder, a +new name will be generated.
return locked ids to prevent them to be updated or the force other ids to use them (the installed version).
set option filter. if null filter is removed. if false only non optional +will be retrieved. if true, only optional will be retrieved.
enable print search result
define repository filter.
define repository filter.
return result as archs
execute query and return result as class loader
execute query and return result as class path string
execute query and return result as definitions
return result as execution entries
execute query and return result as ids
execute query and return install dates
execute query and return install folders
execute query and return install users
return result as artifact names
execute query and return result as nuts path string
return result as osdist names
return result as operating system names
return result as packagings
return result as content path names
return result as content paths
return result as platforms
add runtime id to search
scope filter filter. applicable with {\@link #setInlineDependencies(boolean)}
return javascript filters
update session
sort result
set target api version
set or unset transitive mode
add arch to search
return:NutsSearchCommand
add archs to search
return:NutsSearchCommand
add archs to search
return:NutsSearchCommand
add id to search.
return:NutsSearchCommand
add id to search.
return:NutsSearchCommand
add ids to search.
return:NutsSearchCommand
add ids to search.
return:NutsSearchCommand
add locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsSearchCommand
add locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsSearchCommand
define locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsSearchCommand
define locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsSearchCommand
add packaging to search
return:NutsSearchCommand
add packagings to search
return:NutsSearchCommand
add packagings to search
return:NutsSearchCommand
add repositories to search into
return:NutsSearchCommand
add repositories to search into
return:NutsSearchCommand
add repository to search into
return:NutsSearchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean)} +and {\@link #setDependenciesTree(boolean)}
return:NutsSearchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean)} +and {\@link #setDependenciesTree(boolean)}
return:NutsSearchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean)} +and {\@link #setDependenciesTree(boolean)}
return:NutsSearchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean)} +and {\@link #setDependenciesTree(boolean)}
return:NutsSearchCommand
add javascript filter.
return:NutsSearchCommand
add javascript filter.
return:NutsSearchCommand
add javascript filter.
return:NutsSearchCommand
reset searched for archs
return:NutsSearchCommand
reset ids to search for
return:NutsSearchCommand
reset locked ids
return:NutsSearchCommand
reset packagings to search
return:NutsSearchCommand
reset repositories to search into
return:NutsSearchCommand
remove all dependency scope filters.
return:NutsSearchCommand
remove all javascript filters
return:NutsSearchCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) +} +to help return a more specific return type;
return:NutsSearchCommand
create new instance copy of this
return:NutsSearchCommand
copy content from given {\@code other}
return:NutsSearchCommand
copy content from given {\@code other}
return:NutsSearchCommand
copy session
return:NutsSearchCommand
execute query and return result as class loader
return:ClassLoader
execute query and return store location path
return:NutsResultList
execute query and return the selected columns. +Supported columns are : +\<ul> +\<li>all\</li> +\<li>long\</li> +\<li>status\</li> +\<li>install-date\</li> +\<li>install-user\</li> +\<li>install-folder\</li> +\<li>repository\</li> +\<li>repository-id\</li> +\<li>id\</li> +\<li>name\</li> +\<li>arch\</li> +\<li>packaging\</li> +\<li>platform\</li> +\<li>os\</li> +\<li>osdist\</li> +\<li>exec-entry\</li> +\<li>file-name\</li> +\<li>file\</li> +\<li>var-location\</li> +\<li>temp-folder\</li> +\<li>config-folder\</li> +\<li>lib-folder\</li> +\<li>log-folder\</li> +\<li>cache-folder\</li> +\<li>apps-folder\</li> +\</ul>
return:NutsResultList
search for included (in other installations as dependency) packages
return:NutsSearchCommand
search for non installed packages
return:NutsSearchCommand
search for non installed or included (in other installations as dependency) packages
return:NutsSearchCommand
search for non installed packages
return:NutsSearchCommand
remove arch to search
return:NutsSearchCommand
remove id to search.
return:NutsSearchCommand
remove id to search.
return:NutsSearchCommand
remove locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsSearchCommand
remove locked ids to prevent them to be updated or the force other ids to use them (the installed version).
return:NutsSearchCommand
remove packaging from search
return:NutsSearchCommand
add repository to search into
return:NutsSearchCommand
add dependency scope filter. Only relevant with {\@link #setDependencies(boolean)} +and {\@link #setDependenciesTree(boolean)}
return:NutsSearchCommand
remove dependency scope filter. Only relevant with {\@link #setDependencies(boolean)} +and {\@link #setDependenciesTree(boolean)}
return:NutsSearchCommand
remove javascript filter.
return:NutsSearchCommand
execute the command and return this instance
return:NutsSearchCommand
all artifacts (local and remote). If local result found will any way +fetch remote.
return:NutsSearchCommand
unset location to store to fetched id and fall back to default location.
return:NutsSearchCommand
local only (installed or not)
return:NutsSearchCommand
local or remote. If local result found will not fetch remote.
return:NutsSearchCommand
remote only
return:NutsSearchCommand
sort results. Comparator should handle types of the result.
return:NutsSearchCommand
create fetch command initialized with this instance options.
return:NutsFetchCommand
\@author vpc +\@since 0.5.4 +\@category Commands
update session
return:NutsUndeployCommand
return:NutsUndeployCommand
return:NutsUndeployCommand
return:NutsUndeployCommand
return:NutsUndeployCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsUndeployCommand
copy session
return:NutsUndeployCommand
execute the command and return this instance
return:NutsUndeployCommand
return:NutsUndeployCommand
return:NutsUndeployCommand
return:NutsUndeployCommand
\@author vpc +\@since 0.5.4 +\@category Commands
update session
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsUninstallCommand
copy session
return:NutsUninstallCommand
return:NutsUninstallCommand
return:NutsUninstallCommand
execute the command and return this instance
return:NutsUninstallCommand
return:NutsUninstallCommand
\@author vpc +\@since 0.5.4 +\@category Commands
set target api version required for updating other artifacts
if true enable installing new artifacts when an update is request for +non installed packages.
when true include optional dependencies
execute update check (if not already performed) then return result
update session
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
check for updates.
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
update workspace companion versions
return:NutsUpdateCommand
return:NutsUpdateCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsUpdateCommand
copy session
return:NutsUpdateCommand
update installed artifacts
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
execute the command and return this instance
return:NutsUpdateCommand
update workspace runtime version
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
update api, runtime, extensions, companions and all installed artifacts
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
return:NutsUpdateCommand
update api, runtime, extensions and companions
return:NutsUpdateCommand
Generic Add options
author vpc +\@since 0.5.7 +\@category Commands
update current session
component update result
\@author vpc +\@since 0.5.4 +\@category Commands
return available definition or null
return update dependencies
artifact id
return installed/local definition or null
return true if the update was applied
return true if any update is available. +equivalent to {\@code isUpdateVersionAvailable() || isUpdateStatusAvailable()}
return true if the update was forced
return true if artifact has no version update +but still have status (default) to be updated
return true if artifact has newer available version
Generic Command for usual workspace operations. All Command classes have a +\'run\' method to perform the operation.
\@author vpc +\@since 0.5.5 +\@category Commands
update session
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsWorkspaceCommand
copy session
return:NutsWorkspaceCommand
execute the command and return this instance
return:NutsWorkspaceCommand
Created by vpc on 6/23/17.
\@since 0.5.5 +\@category Commands
Generic Add options
\@author vpc +\@see NutsWorkspaceConfigManager#addSdk(net.vpc.app.nuts.NutsSdkLocation, +net.vpc.app.nuts.NutsAddOptions) +\@see NutsWorkspaceConfigManager#addCommandAlias(net.vpc.app.nuts.NutsCommandAliasConfig, +net.vpc.app.nuts.NutsAddOptions) +\@see NutsWorkspaceConfigManager#addCommandAliasFactory(net.vpc.app.nuts.NutsCommandAliasFactoryConfig, +net.vpc.app.nuts.NutsAddOptions) +\@since 0.5.4 +\@category Config
update current session
return:boolean
return:int
return:String
repository creation options +\@author vpc +\@since 0.5.4 +\@category Config
default constructor
copy constructor
repository config information
always create. Throw exception if found
repository deploy order
enabled repository
fail safe repository. when fail safe, repository will be ignored +if the location is not accessible
repository location
repository name (should no include special space or characters)
create a proxy for the created repository
current session
temporary repository
create a copy of this instance
return:NutsAddRepositoryOptions
return:boolean
return:int
return:String
Command Alias definition class Config +\@author vpc +\@since 0.5.4 +\@category Config
alias command arguments
alias command execution options
alias factory id
alias help command (command to display help)
alias help text (meaningful if helpCommand is not defined)
alias name
alias definition
return:boolean
return:int
return:String
\@author vpc +\@category Config
Workspace creation/opening options class.
\@since 0.5.4 +\@category Config
creates a string key combining layout and location. +le key has the form of a concatenated layout and location ids separated by \':\' +where null layout is replaced by \'system\' keyword. +used in {\@link NutsWorkspaceOptions#getHomeLocations()}.
return:String
set apiVersion
set applicationArguments
set archetype
set provider
set confirm
set creationTime
set password
set debug
set dry
set excludedExtensions
set excludedRepositories
set executionType
set executorOptions
set global
set gui
set inherited
set javaOptions
set logConfig
set workspace name
set openMode
set outputFormat
set output format options
set readOnly
set recover
set repositoryStoreLocationStrategy
set reset
set runtimeId
set skipWelcome
set skipInstallCompanions
set skipWelcome
set storeLocationLayout
set storeLocationStrategy
set terminalMode
set trace
set transientRepositories
set login
set workspace
add output format options
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsFormat
parse arguments
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
set home location
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
set store location
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:String
Extension information +\@author vpc +\@since 0.5.4 +\@category Config
extension main author(s)
extension category
extension long description
extension id
extension user name
extension source
\@author vpc +\@since 0.5.4 +\@category Config
return:boolean
return:int
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:NutsRepositoryConfig
return:String
\@author vpc +\@since 0.5.4 +\@category Config
global name is independent from workspace
name is the name attributed by the containing workspace. It is defined in +NutsRepositoryRef
add new repository
return:NutsRepository
add new repository
return:NutsRepository
search for (or return null) a repository with the given repository name or id.
return:NutsRepository
return:NutsRepository
return:NutsRepository
return repository configured location as string
return:String
search for (or throw error) a repository with the given repository name or id.
return:NutsRepository
return:String
return:NutsRepositoryConfigManager
return:boolean
return:NutsRepositoryConfigManager
return:NutsRepositoryConfigManager
return:NutsRepositoryConfigManager
return:NutsRepositoryConfigManager
return:NutsRepositoryConfigManager
return:NutsRepositoryConfigManager
return:String
\@author vpc +\@since 0.5.4 +\@category Config
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:NutsRepositoryDefinition
return:String
SDK location +\@author vpc +\@since 0.5.4 +\@category Config
default constructor
sdk name
sdk packaging. for Java SDK this +is room to set JRE or JDK.
sdk path
sdk product. In java this is +Oracle JDK or OpenJDK.
sdk version
return:boolean
return:int
return:String
\@author vpc +\@since 0.5.5 +\@category Config
update session
add path if repoOrPath is a path (contains path separator or is \'.\' or \'..\') +if not add repo name or id
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsUpdateStatisticsCommand
copy session
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
return:NutsUpdateStatisticsCommand
execute the command and return this instance
return:NutsUpdateStatisticsCommand
Effective (including inherited) user information +\@author vpc +\@since 0.5.4 +\@category Config
user groups
user inherited allowed permissions
user allowed permissions
return remote identity if applicable
return user name
true if the use has some credentials
return:boolean
\@author vpc +\@since 0.5.4 +\@category Config
return:boolean
return:int
return:String
\@author vpc +\@since 0.5.4 +\@category Config
\@author vpc +\@since 0.5.4 +\@category Config
return:NutsCommandAliasConfig
return:List
\@author vpc +\@since 0.5.4 +\@category Config
all home locations key/value map where keys are in the form +"osfamily:location" and values are absolute paths.
all home locations key/value map where keys are in the form "location" +and values are absolute paths.
return:boolean
return:NutsRepository
return:NutsRepository
add temporary repository
return:NutsRepository
creates a new repository from the given {\@code repositoryNamedUrl}.
Accepted {\@code repositoryNamedUrl} values are : +\<ul> +\<li>\'local\' : corresponds to a local updatable repository. will be named +\'local\'\</li> +\<li>\'m2\', \'.m2\', \'maven-local\' : corresponds the local maven folder +repository. will be named \'local\'\</li> +\<li>\'maven-central\': corresponds the remote maven central repository. +will be named \'local\'\</li> +\<li>\'maven-git\', \'vpc-public-maven\': corresponds the remote maven +vpc-public-maven git folder repository. will be named \'local\'\</li> +\<li>\'maven-git\', \'vpc-public-nuts\': corresponds the remote nuts +vpc-public-nuts git folder repository. will be named \'local\'\</li> +\<li>name=uri-or-path : corresponds the given uri. will be named name. +Here are some examples: +\<ul> +\<li>myremote=http://192.168.6.3/folder\</li> +\<li>myremote=/folder/subfolder\</li> +\<li>myremote=c:/folder/subfolder\</li> +\</ul> +\</li> +\<li>uri-or-path : corresponds the given uri. will be named uri\'s last +path component name. Here are some examples: +\<ul> +\<li>http://192.168.6.3/folder : will be named \'folder\'\</li> +\<li>myremote=/folder/subfolder : will be named \'folder\'\</li> +\<li>myremote=c:/folder/subfolder : will be named \'folder\'\</li> +\</ul> +\</li> +\</ul>
return:NutsRepository
return:boolean
return:NutsId
return:NutsRepository
return:NutsWorkspaceListManager
return:NutsWorkspaceCommandAlias
return alias definition for given name id and owner.
return:NutsWorkspaceCommandAlias
return:List
return:List
return:NutsRepository
return:NutsRepository
return:NutsRepository
return:NutsSdkLocation
return:NutsSdkLocation
return:NutsSdkLocation
return:NutsSdkLocation
return:String
return:NutsWorkspaceOptions
return:boolean
return:boolean
return:NutsWorkspaceConfigManager
return:NutsSdkLocation
return:Path
verify if the path is a valid sdk path and return null if not
return:NutsSdkLocation
save config file if force is activated or non read only and some changes +was detected in config file
return:boolean
return:NutsSdkLocation[]
return:NutsSdkLocation[]
return:NutsWorkspaceStoredConfig
Class for managing a Workspace list
\@author Nasreddine Bac Ali +date 2019-03-02 +\@since 0.5.4 +\@category Config
return:NutsWorkspaceListConfig
return:NutsWorkspaceListConfig
return:String
Class for managing a Workspace list
\@author Nasreddine Bac Ali +date 2019-03-02 +\@since 0.5.4 +\@category Config
return:NutsWorkspace
return:boolean
return:NutsWorkspaceListManager
Class for managing a Workspace list
\@author Nasreddine Bac Ali +date 2019-03-02 +\@since 0.5.4 +\@category Config
return:NutsWorkspaceLocation
return:boolean
return:int
return:NutsWorkspaceLocation
return:NutsWorkspaceLocation
return:NutsWorkspaceLocation
return:NutsWorkspaceLocation
return:String
\@author vpc +\@since 0.5.4 +\@category Config
return:NutsWorkspaceOpenMode
return:NutsWorkspaceOpenMode[]
lower cased identifier.
return:String
Workspace options class that holds command argument information.
\@since 0.5.4 +\@category Config
nuts api version to boot. +\<p> +\<strong>option-type :\</strong> exported (inherited in child +workspaces)
application arguments. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
workspace archetype to consider when creating a new workspace. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime)
boot repositories \';\' separated
\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
when true, use cache +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
class loader supplier. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
confirm mode. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
workspace creation evaluated time. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
credential needed to log into workspace. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true, extra debug information is written to standard output. +Particularly, exception stack traces are displayed instead of simpler messages. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
if true no real execution, wil dry exec (execute without side effect). +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
extensions to be excluded when opening the workspace. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
repository list to be excluded when opening the workspace. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
execution type. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
extra executor options. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
executor service used to create worker threads. when null, use default. +this option cannot be defined via arguments.
\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
default fetch strategy +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true consider global/system repository +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true consider GUI/Swing mode +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
return home locations. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime).
when true, use index +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true, workspace were invoked from parent process and hence inherits its options. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
java command (or java home) used to run workspace. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
java options used to run workspace. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
workspace log configuration. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
user friendly workspace name. +\<p> +\<strong>option-type :\</strong> exported (inherited in child +workspaces)
mode used to open workspace. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
default output format type. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
default output formation options. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
return progress options string. +progress options configures how progress monitors are processed. +\'no\' value means that progress is disabled. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true, workspace configuration are non modifiable. +However cache stills modifiable so that it is possible to load external libraries. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true, boot, cache and temp folder are deleted. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
repository store location strategy to consider when creating new repositories +for a new workspace. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime)
if true, workspace will be reset (all configuration and runtime files deleted). +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
nuts runtime id (or version) to boot.
\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true, do not bootstrap workspace after reset/recover. +When reset/recover is not active this option is not accepted and an error will be thrown +\<p> +defaults to false. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
if true, do not install nuts companion tools upon workspace creation. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
if true, do not run welcome when no application arguments were resolved. +\<p> +defaults to false. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
default standard error. when null, use {\@code System.err} +this option cannot be defined via arguments.
\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
default standard input. when null, use {\@code System.in} +this option cannot be defined via arguments.
\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
default standard output. when null, use {\@code System.out} +this option cannot be defined via arguments.
\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
store location layout to consider when creating a new workspace. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime)
store location strategy for creating a new workspace. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime)
store locations map to consider when creating a new workspace. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime)
terminal mode (inherited, formatted, filtered) to use. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
when true, extra trace user-friendly information is written to standard output. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
repositories to register temporarily when running the workspace. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
when true, use transitive repositories +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
username to log into when running workspace. +\<p> +\<strong>option-type :\</strong> exported (inherited in child workspaces)
workspace folder location path. +\<p> +\<strong>option-type :\</strong> exported (inherited in child +workspaces)
create a \<strong>mutable\</strong> copy of this instance
return:NutsWorkspaceOptionsBuilder
create a new instance of options formatter that help formatting this instance.
return:NutsWorkspaceOptionsFormat
return home location. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime).
return:String
store location for the given folder. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime)
return:String
Mutable Workspace options +\@category Config
set home locations. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime).
if true, do not bootstrap workspace after reset/recover. +When reset/recover is not active this option is not accepted and an error will be thrown +\<p> +defaults to false. +\<p> +\<strong>option-type :\</strong> runtime (available only for the current workspace instance)
set store location strategy for creating a new workspace. +\<p> +\<strong>option-type :\</strong> create (used when creating new workspace. will not be +exported nor promoted to runtime)
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
return:NutsWorkspaceOptionsBuilder
Nuts read-only configuration
\@author vpc +\@since 0.5.4 +\@category Config
all home locations key/value map where keys are in the form +"osfamily:location" and values are absolute paths.
all home locations key/value map where keys are in the form "location" +and values are absolute paths.
Common Nuts constants. Represents various constants used in runtime +implementation. +\<p> +Created by vpc on 1/14/17.
\@since 0.1.0 +\@category Constants
classifier selector immutable class. +Nuts can select artifact classifier according to filters based on arch, os, os dist and platform. +This class defines the mapping to classifier to consider if all the filters. +When multiple selectors match, the first on prevails. +\@since 0.5.7 +\@category Descriptor
arch list filter. +al least one of the list must match.
classifier to select
os list filter. +al least one of the list must match.
os distribution list filter. +al least one of the list must match.
packaging to select
platform list filter. +al least one of the list must match.
classifier selector builder class. +Nuts can select artifact classifier according to filters based on arch, os, os dist and platform. +This class defines the mapping to classifier to consider if all the filters. +When multiple selectors match, the first on prevails.
\@since 0.5.7 +\@category Descriptor
set archs
set classifier
set oses
set os dists
set packaging
set platforms
create new instance of {\@link NutsClassifierMapping} initialized with this builder\'s values.
return:NutsClassifierMapping
clear all values / reset builder
return:NutsClassifierMappingBuilder
copy all values from the given builder
return:NutsClassifierMappingBuilder
copy all values from the given instance
return:NutsClassifierMappingBuilder
Content describes a artifact file location and its characteristics. +\@author vpc +\@since 0.5.4 +\@category Descriptor
when true, the content was retrieved from cache rather then from remote location.
artifact local path
when true, the path location is temporary and should be deleted after usage
Default Content implementation. +\@author vpc +\@since 0.5.4 +\@category Descriptor
Default Content implementation constructor
true if the file is cached (may be not up to date)
content path location
true if file is temporary (should be deleted later)
return:boolean
return:int
return:String
NutsDependency is an \<strong>immutable\</strong> object that contains all information about a component\'s dependency. +\@author vpc +\@since 0.5.3 +\@category Descriptor
return artifact id (aka artifactId)
get classifier string value (may be $ var)
dependency exclusions
return dependency full name in the form +namespace://group:name#version?scope=<scope>{\@code &}optional=<optional>
return artifact group id (aka groupId in maven)
convert to NutsId
return dependency full name in the form +group:name#version
return namespace
Indicates the dependency is optional for use of this library.
properties in the url query form
properties in the url query form
get scope string value (may be $ var).
return dependency full name in the form +group:name
return dependency version
return mutable id builder instance initialized with {\@code this} instance.
return:NutsDependencyBuilder
Dependency Builder (mutable). +User should use available \'set\' method and finally call {\@link #build()} +to get an instance of immutable NutsDependency
\@author vpc +\@since 0.5.4 +\@category Descriptor
set name value
set classifier value
reset this instance with value
set exclusions value
return full name
set group value
set id value
set namespace value
set optional value
set scope value
set version value
return:NutsDependencyBuilder
return:NutsDependencyBuilder
build new instance of NutsDependencies
return:NutsDependency
reset this instance
return:NutsDependencyBuilder
reset this instance with value
return:NutsDependencyBuilder
reset this instance with value
return:NutsDependencyBuilder
return:NutsDependencyBuilder
return:NutsDependencyBuilder
return:NutsDependencyBuilder
Dependency filter
\@since 0.5.4 +\@category Descriptor
return true if the {\@code dependency} is accepted
return:boolean
Supported dependency scope lists +\@author vpc +\@since 0.5.4 +\@category Descriptor
return:NutsDependencyScope
return:NutsDependencyScope[]
lower cased identifier.
return:String
Supported dependency scope pattern. +A dependency scope pattern +\@author vpc +\@since 0.5.6 +\@category Descriptor
return:NutsDependencyScopePattern
return:NutsDependencyScopePattern[]
lower cased identifier.
return:String
Dependency tree node +\@author vpc +\@since 0.5.5 +\@category Descriptor
node children
node dependency
true if the node is partial filled (not all children are considered)
Nuts descriptors define an \<strong>immutable\</strong> image to all information needed to execute an artifact. +It resembles to maven\'s pom file but it focuses on execution information +rather then build information. Common features are inheritance +dependencies, standard dependencies, exclusions and properties. +However nuts descriptor adds new features such as : +\<ul> +\<li>multiple parent inheritance\</li> +\<li>executable/nuts-executable flag\</li> +\<li>environment (arch, os, dist,platform) filters\</li> +\<li>classifiers may be mapped to environment (think of dlls for windows and so for linux)\</li> +\</ul> +A versatile way to change descriptor is to use builder ({\@link #builder()}).
\@since 0.1.0 +\@category Descriptor
true if the artifact is a java executable that implements {\@link NutsApplication} interface.
supported archs. if empty, all arch are supported (for example for java, all arch are supported).
ordered list of classifier mapping used to resolve valid classifier to use of ra given environment.
list of immediate (non inherited and non transitive dependencies
long description for the artifact
true if the artifact is executable and is considered an application. if not it is a library.
descriptor of artifact responsible of running this artifact
artifact full id (groupId+artifactId+version)
descriptor of artifact responsible of installing this artifact
list of available mirror locations from which nuts can download artifact content. +location can be mapped to a classifier.
user friendly name, a short description for the artifact
supported operating systems. if empty, all oses are supported (for example for java, all arch are supported).
supported operating system distributions (mostly for linux systems). if empty, all distributions are supported.
return descriptor packaging (used to resolve file extension)
descriptor parent list (may be empty)
supported platforms (java, dotnet, ...). if empty patform is not relevant. +This is helpful to bind application to a jdk version for instance (in that case platform may be in the form java#8 for instance)
custom properties that can be used as place holders (int ${name} form) in other fields.
The dependencies specified here are not used until they are referenced in +a POM within the group. This allows the specification of a +"standard" version for a particular. This corresponds to +"dependencyManagement.dependencies" in maven
create new builder filled with this descriptor fields.
return:NutsDescriptorBuilder
Nuts descriptors define a \<strong>mutable\</strong> image to all information needed to execute an artifact. +It help creating an instance of {\@link NutsDescriptor} by calling {\@link #build()}
\@since 0.5.4 +\@category Descriptor
set nutsApp flag
set archs
set classifier mappings
set dependencies
set description
set executable flag
set executor flag
set id
set installer
set locations
set name
true if the artifact is a java executable that implements {\@link NutsApplication} interface.
set os
set osdist
set packaging
set parents
set platform
set properties
set standard dependencies
add arch
return:NutsDescriptorBuilder
add classifier mapping
return:NutsDescriptorBuilder
add dependencies
return:NutsDescriptorBuilder
add dependency
return:NutsDescriptorBuilder
add location
return:NutsDescriptorBuilder
add os
return:NutsDescriptorBuilder
add os dist
return:NutsDescriptorBuilder
add platform
return:NutsDescriptorBuilder
merge properties
return:NutsDescriptorBuilder
add standard dependencies
return:NutsDescriptorBuilder
add standard dependency
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
merge parent and child information (apply inheritance)
return:NutsDescriptorBuilder
replace placeholders with the corresponding property value in properties list
return:NutsDescriptorBuilder
replace placeholders with the corresponding property value in the given properties list and return a new instance.
return:NutsDescriptorBuilder
set archs
return:NutsDescriptorBuilder
create new Descriptor filled with this builder fields.
return:NutsDescriptor
return:NutsDescriptorBuilder
clear this instance (set null/default all properties)
return:NutsDescriptorBuilder
set dependencies
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
set name
return:NutsDescriptorBuilder
set os
return:NutsDescriptorBuilder
set osdist
return:NutsDescriptorBuilder
set packaging
return:NutsDescriptorBuilder
set parents
return:NutsDescriptorBuilder
set platform
return:NutsDescriptorBuilder
set properties
return:NutsDescriptorBuilder
return:NutsDescriptorBuilder
remove arch
return:NutsDescriptorBuilder
remove dependency
return:NutsDescriptorBuilder
create a new instance of descriptor with removed dependencies that match the predicate
return:NutsDescriptorBuilder
remove os
return:NutsDescriptorBuilder
remove osdist
return:NutsDescriptorBuilder
remove platform
return:NutsDescriptorBuilder
remove standard dependency
return:NutsDescriptorBuilder
create a new instance of descriptor with added/merged dependencies
return:NutsDescriptorBuilder
create a new instance of descriptor with added/merged properties
return:NutsDescriptorBuilder
set all fields from {\@code other}
return:NutsDescriptorBuilder
set all fields from {\@code other}
return:NutsDescriptorBuilder
set or unset property. +if the value is null, the property is removed.
return:NutsDescriptorBuilder
set standard dependencies
return:NutsDescriptorBuilder
Descriptor filter
\@since 0.5.4 +\@category Descriptor
return true if descriptor is accepted
return:boolean
default implementation of {\@link NutsSearchIdFilter}
return:boolean
Class describing executable command. +\@author vpc +\@since 0.5.4 +\@category Descriptor
executable description
executable help string
executable artifact id
executable name
return executable type
versatile executable name
Executable command type returned by which internal command +\@author vpc +\@since 0.5.4 +\@category Descriptor
return:NutsExecutableType
return:NutsExecutableType[]
lower cased identifier.
return:String
Execution entry is a class that can be executed. +\@author vpc +\@since 0.5.4 +\@category Descriptor
true if the entry resolved to a valid nuts application
true if the class if registered as main class in META-INF
class name
Immutable Artifact id information. +\@author vpc +\@since 0.1.0 +\@category Descriptor
hardware architecture supported by the artifact
return name part of this id
tag used to distinguish between different artifacts that were built from the same source code
id face define is a release file type selector of the id. +It helps discriminating content (jar) from descriptor, from other (hash,...) +files released for the very same artifact.
return a string representation of this id. All of group, name, version, +namespace, queryMap values are printed. This method is equivalent to +{\@link Object#toString()}
artifact group which identifies uniquely projects and group of projects.
return a string concatenation of group, name and version, +ignoring namespace, and queryMap values. An example of long name is +\<code>my-group:my-artifact#my-version?alt\</code>
return a new instance of NutsId defining only group, name and version, +ignoring namespace, and queryMap values.
artifact namespace (usually repository name or id)
os supported by the artifact
os distribution supported by the artifact
platform supported by the artifact
properties as map.
properties in the url query form
returns a string concatenation of group and name (\':\' separated) ignoring +version,namespace, and queryMap values. In group is empty or null, name +is returned. Ann null values are trimmed to "" An example of simple name +is \<code>my-group:my-artifact\</code>
return a new instance of NutsId defining only group and name ignoring +version,namespace, and queryMap values.
artifact version (never null)
non null token filter that searches in all id fields
return:NutsTokenFilter
non null artifact id token
return:NutsTokenFilter
create a builder (mutable id) based on this id
return:NutsIdBuilder
true if other has exact shot name than {\@code this}
return:boolean
create a filter based on this id
return:NutsIdFilter
non null group id token
return:NutsTokenFilter
non null namespace non null namespace token
return:NutsTokenFilter
non null properties query token
return:NutsTokenFilter
non null version token
return:NutsTokenFilter
Mutable Artifact id information used to create instance of {\@link NutsId} +\@author vpc +\@since 0.5.4 +\@category Descriptor
update arch
update artifactId
update classifier
update id face which defines is a release file type selector
return a string representation of this id. All of group, name, version, +namespace, queryMap values are printed. This method is equivalent to +{\@link Object#toString()}
update groupId
return a string concatenation of group, name and version, +ignoring namespace, and queryMap values. An example of long name is +\<code>my-group:my-artifact#my-version?alt\</code>
update namespace
update os
update osdist
update packaging
update platform
update all properties property.
properties in the url query form
returns a string concatenation of group and name (\':\' separated) ignoring +version,namespace, and queryMap values. In group is empty or null, name +is returned. Ann null values are trimmed to "" An example of simple name +is \<code>my-group:my-artifact\</code>
update setVersion
update all properties property while retaining old, +non overridden properties.
return:NutsIdBuilder
update all properties property while retaining old, +non overridden properties.
return:NutsIdBuilder
replace dollar based variables with the given properties
return:NutsIdBuilder
create new instance of {\@link NutsId} initialized with this builder values.
return:NutsId
clear this instance (set null/default all properties)
return:NutsIdBuilder
update all arguments
return:NutsIdBuilder
update all arguments
return:NutsIdBuilder
equivalent to {\@code setFace(NutsConstants.QueryFaces.CONTENT)}
return:NutsIdBuilder
equivalent to {\@code setFace(NutsConstants.QueryFaces.DESCRIPTOR)}
return:NutsIdBuilder
update property. +When {\@code value} is null, property will be removed.
return:NutsIdBuilder
Class for filtering Artifact Ids
\@since 0.5.4 +\@category Descriptor
return true when the id is to be accepted
return:boolean
return:boolean
This class is used in {\@link NutsDescriptor} to describe +locations/mirrors to download artifact content instead of the +regular location. +\@category Descriptor
classifier for the artifact
location (geographic) region that may be used to select +the most effective mirror
location url of the artifact content
this class represents an \<strong>immutable\</strong> string representation of a version parsed as a suite of alternating numbers and words. +Parsing algorithm is simply to split whenever word type changes. +Examples: +\<ul> +\<li>1 = [1]\</li> +\<li>1.2 = [1,\'.\',2]\</li> +\<li>10.20update3 = [10,\'.\',20,\'update\',3]\</li> +\</ul> +\@author vpc +\@since 0.5.4 +\@category Descriptor
return true if this version denotes as single value and does not match an interval.
return string representation of the version
compare this version to the other version
return:int
return:int
parse the current version as new instance of {\@link NutsVersionFilter}
return:NutsVersionFilter
element at given index. if the index is negative will return from right. +\<ul> +\<li>(1.a22).get(0)=1\</li> +\<li>(1.a22).get(1)=a\</li> +\<li>(1.a22).get(-1)=22\</li> +\</ul>
return:String
number element at given index. if the index is negative will return from right (-1 is the first starting from the right). +The version is first split (as a suite of number and words) then all words are discarded. +\<ul> +\<li>size(1.22)=3 {\'1\',\'.\',\'22\'}\</li> +\<li>size(1.22_u1)=5 {\'1\',\'.\',\'22\',\'_u\',\'1\'}\</li> +\</ul> +\<ul> +\<li>(1.a22).getNumber(0)=1\</li> +\<li>(1.a22).getNumber(1)=22\</li> +\<li>(1.a22).getNumber(-1)=22\</li> +\</ul>
return:int
return number element at position or default value. if the index is negative will return from right (-1 is the first starting from the right). +The version is first split (as a suite of number and words) then all words are discarded.
return:int
increment the last number in the version with 1
return:NutsVersion
increment the number at {\@code position} in the version with 1
return:NutsVersion
increment the last number in the version with the given {\@code amount}
return:NutsVersion
parse the current version as an interval array
return:NutsVersionInterval[]
number of elements in the version. +\<ul> +\<li>numberSize(1.22)=2 {1,22}\</li> +\<li>numberSize(1.22_u1)=3 {1,22,1}\</li> +\</ul>
return:int
number of elements in the version. +\<ul> +\<li>size(1.22)=3 {\'1\',\'.\',\'22\'}\</li> +\<li>size(1.22_u1)=5 {\'1\',\'.\',\'22\',\'_u\',\'1\'}\</li> +\</ul>
return:int
version interval is a version filter that accepts interval ranges of versions.
version intervals can be in one of the following forms +\<pre> +[ version, ] +] version, ] or ( version, ] +[ version, [ or [ version, ) +] version, [ or ] version, [
[ ,version ] +] ,version ] or ( ,version ] +[ ,version [ or [ ,version ) +] ,version [ or ] ,version [
[ version1 , version2 ] +] version1 , version2 ] or ( version1 , version2 ] +[ version1 , version2 [ or [ version1 , version2 ) +] version1 , version2 [ or ] version1 , version2 [
comma or space separated intervals such as : +[ version1 , version2 ], [ version1 , version2 ][ version1 , version2 ] [ version1 , version2 ] +\</pre>
Created by vpc on 1/8/17. +\@since 0.5.4 +\@category Descriptor
true if the version is accepted by this instance filter
return:boolean
true if the version is accepted by this instance filter
return:boolean
Array implementation of Nuts Element type. +Nuts Element types are generic JSON like parsable objects. +\@author vpc +\@since 0.5.6 +\@category Elements
array items
return:Collection
element at index
return:NutsElement
element count
return:int
Array element Builder is a mutable NutsArrayElement that helps +manipulating arrays. +\@author vpc +\@category Elements
add new element to the end of the array.
return:NutsArrayElementBuilder
all all elements in the given array
return:NutsArrayElementBuilder
all all elements in the given array builder
return:NutsArrayElementBuilder
create array with this instance elements
return:NutsArrayElement
array items
return:List
remove all elements from this array.
return:NutsArrayElementBuilder
element at index
return:NutsElement
insert new element at the given index.
return:NutsArrayElementBuilder
add new element to the end of the array.
return:NutsArrayElementBuilder
reset this instance with the given array
return:NutsArrayElementBuilder
reset this instance with the given array
return:NutsArrayElementBuilder
update element at the given index.
return:NutsArrayElementBuilder
element count
return:int
Nuts Element types are generic JSON like parsable objects. +\@author vpc +\@since 0.5.6 +\@category Elements
convert this element to {\@link NutsArrayElement} or throw ClassCastException
return:NutsArrayElement
convert this element to {\@link NutsObjectElement} or throw ClassCastException
return:NutsObjectElement
convert this element to {\@link NutsPrimitiveElement} or throw ClassCastException
return:NutsPrimitiveElement
element type
return:NutsElementType
Nuts Element builder that helps creating element instances. +\@author vpc +\@category Elements
create array element builder (mutable)
return:NutsArrayElementBuilder
create primitive boolean element
return:NutsPrimitiveElement
create primitive boolean element
return:NutsPrimitiveElement
create primitive date element
return:NutsPrimitiveElement
create primitive date element
return:NutsPrimitiveElement
create primitive date element
return:NutsPrimitiveElement
create primitive null element
return:NutsPrimitiveElement
create primitive number element
return:NutsPrimitiveElement
create primitive number element
return:NutsPrimitiveElement
create object element builder (mutable)
return:NutsObjectElementBuilder
create primitive string element
return:NutsPrimitiveElement
Element XPath like filter
\@author vpc +\@category Elements
filter element to a valid children list
return:List
filter elements to a valid children list
return:List
Element type. this an extension of json element types. +\@author vpc +\@category Elements
return:NutsElementType
return:NutsElementType[]
true if private type
lower cased identifier.
return:String
Object implementation of Nuts Element type. +Nuts Element types are generic JSON like parsable objects. +\@author vpc +\@since 0.5.6 +\@category Elements
object (key,value) attributes
return:Collection
return value for name or null. +If multiple values are available return any of them.
return:NutsElement
element count
return:int
primitive values implementation of Nuts Element type. Nuts Element types are +generic JSON like parsable objects.
\@author vpc +\@since 0.5.6 +\@category Elements
value as any java Boolean. Best effort is applied to convert to this +type.
value as any java date. Best effort is applied to convert to this type.
true if the value is or can be converted to double
true if the value is or can be converted to float
true if the value is or can be converted to int.
true if the value is or can be converted to long.
true if the value is null (in which case, the type should be NULL)
value as any java Number. Best effort is applied to convert to this type.
value as any java string. Best effort is applied to convert to this type.
value as any java Object
A class can implement the \<code>NutsInstallListener\</code> interface when it +wants to be informed of install artifacts actions.
\@author vpc +\@since 0.5.4 +\@category Events
This method is called whenever the observed workspace installs an artifact.
This method is called whenever the observed workspace uninstalls an artifact.
This method is called whenever the observed workspace updates an artifact.
Repository Event +\@author vpc +\@since 0.5.4 +\@category Events
Parent repository when this event is about creating +a new repository with a parent one.
event property name
event property old value
event property new value
repository that fires this event or the new repository +when creating a new one with parent.
current session
current workspace
Created by vpc on 1/20/17.
\@since 0.5.4 +\@category Events
\@author vpc +\@since 0.5.6 +\@category Events
\@author vpc +\@since 0.5.4 +\@category Events
Created by vpc on 1/20/17.
\@since 0.5.4 +\@category Events
Exception fired in {\@link NutsWorkspace#deploy()} method if the package is +already deployed Created by vpc on 1/15/17.
\@since 0.5.4 +\@category Exception
Custom Constructor
Custom Constructor
Custom Constructor
Custom Constructor
Thrown to indicate that the artifact is already installed and should not be +reinstalled Created by vpc on 1/15/17.
\@since 0.5.4 +\@category Exception
Custom Constructor
Custom Constructor
Custom Constructor
Custom Constructor
Generic exception to be thrown when an element is not found. +\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new runtime exception with {\@code null} as its +detail message. The cause is not initialized, and may subsequently be +initialized by a call to {\@link #initCause}.
Constructs a new runtime exception with the specified cause and a +detail message of \<tt>(cause==null ? null : cause.toString())\</tt> +(which typically contains the class and detail message of +\<tt>cause\</tt>). This constructor is useful for runtime exceptions +that are little more than wrappers for other throwables.
Constructs a new runtime exception with the specified detail message. +The cause is not initialized, and may subsequently be initialized by a +call to {\@link #initCause}.
Constructs a new runtime exception with the specified detail message and +cause. \<p>Note that the detail message associated with +{\@code cause} is \<i>not\</i> automatically incorporated in +this runtime exception\'s detail message.
Constructs a new runtime exception with the specified detail +message, cause, suppression enabled or disabled, and writable +stack trace enabled or disabled.
Base Nuts Exception. Parent of all Nuts defined Exceptions. +\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new runtime exception with {\@code null} as its +detail message. The cause is not initialized, and may subsequently be +initialized by a call to {\@link #initCause}.
Constructs a new runtime exception with the specified cause and a +detail message of \<tt>(cause==null ? null : cause.toString())\</tt> +(which typically contains the class and detail message of +\<tt>cause\</tt>). This constructor is useful for runtime exceptions +that are little more than wrappers for other throwables.
Constructs a new runtime exception with the specified cause and a +detail message of \<tt>(cause==null ? null : cause.toString())\</tt> +(which typically contains the class and detail message of +\<tt>cause\</tt>). This constructor is useful for runtime exceptions +that are little more than wrappers for other throwables.
Constructs a new runtime exception with the specified detail message. +The cause is not initialized, and may subsequently be initialized by a +call to {\@link #initCause}.
Constructs a new runtime exception with the specified detail message and +cause. \<p>Note that the detail message associated with +{\@code cause} is \<i>not\</i> automatically incorporated in +this runtime exception\'s detail message.
Constructs a new runtime exception with the specified detail +message, cause, suppression enabled or disabled, and writable +stack trace enabled or disabled.
Returns the workspace of this Nuts Exception.
Standard Execution thrown when an artifact fails to run.
\@since 0.5.4 +\@category Exception
Constructs a new NutsExecutionException exception
Constructs a new NutsExecutionException exception
Constructs a new NutsExecutionException exception
Constructs a new NutsExecutionException exception
Constructs a new NutsExecutionException exception
Constructs a new NutsExecutionException exception
Constructs a new NutsExecutionException exception
artifact exit code
Exception thrown when extension is already registered.
\@since 0.5.4 +\@category Exception
Constructs a new NutsExtensionAlreadyRegisteredException exception
Constructs a new NutsExtensionAlreadyRegisteredException exception
registered/installed extension
Base exception for Extension related exceptions
\@since 0.5.4 +\@category Exception
Constructs a new runtime exception with the specified detail message and +cause. \<p>Note that the detail message associated with +{\@code cause} is \<i>not\</i> automatically incorporated in +this runtime exception\'s detail message.
extension id
Exception thrown when extension could not be resolved.
\@since 0.5.4 +\@category Exception
Constructs a new NutsExtensionNotFoundException exception
extension name
missing type
Exception thrown when a component cannot be resolved by the factory. +\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsFactoryException exception
Constructs a new NutsFactoryException exception
Constructs a new NutsFactoryException exception
Constructs a new NutsFactoryException exception
Constructs a new NutsFactoryException exception
Constructs a new NutsFactoryException exception
Created by vpc on 1/15/17.
\@since 0.5.4 +\@category Exception
Constructs a new NutsFetchModeNotSupportedException exception
Constructs a new NutsFetchModeNotSupportedException exception
fetch mode
artifact id
repository name
repository uuid
Thrown to indicate that a method has been passed an illegal or inappropriate argument. +\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsIllegalArgumentException exception
Constructs a new NutsIllegalArgumentException exception
Constructs a new NutsIllegalArgumentException exception
Constructs a new NutsIllegalArgumentException exception
Constructs a new NutsIllegalArgumentException exception
Created by vpc on 1/15/17.
\@since 0.5.4 +\@category Exception
Custom Constructor
Custom Constructor
Custom Constructor
Custom Constructor
Base exception for installation fails.
\@since 0.5.4 +\@category Exception
Custom Constructor
Custom Constructor
nuts id
This Exception is thrown when the repository fails to initialize.
\@since 0.5.4 +\@category Exception
Constructs a new NutsInvalidRepositoryException exception
This Exception is thrown when the workspace fails to initialize.
\@since 0.5.4 +\@category Exception
Constructs a new NutsInvalidWorkspaceException exception
workspace location
Exception Thrown when a locked object is invoked. +\@author vpc +\@category Exception
Constructs a new ock exception.
Constructs a new ock exception.
Constructs a new ock exception.
Exception Thrown when a locked object is invoked. +\@author vpc +\@category Exception
Constructs a new lock exception.
Constructs a new lock exception.
Constructs a new lock exception.
Exception Thrown when a locked object is invoked. +\@author vpc +\@category Exception
Constructs a new ock exception.
Constructs a new ock exception.
Constructs a new ock exception.
return lock object
return locked object
Exception Thrown when a locked object is invoked. +\@author vpc +\@category Exception
Constructs a new ock exception.
Constructs a new ock exception.
Constructs a new ock exception.
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsLoginException exception
Constructs a new NutsLoginException exception
Constructs a new NutsLoginException exception
Constructs a new NutsLoginException exception
Constructs a new NutsLoginException exception
Exception thrown when a non executable nuts id is requested to run.
\@since 0.5.4 +\@category Exception
Constructs a new NutsNotExecutableException exception
Constructs a new NutsNotExecutableException exception
artifact id
Exception thrown when the package could not be resolved
\@since 0.5.4 +\@category Exception
Constructs a new NutsNotFoundException exception
Constructs a new NutsNotFoundException exception
Constructs a new NutsNotFoundException exception
Constructs a new NutsNotFoundException exception
Constructs a new NutsNotFoundException exception
artifact id
This exception is thrown when an artifact fails to be installed.
\@since 0.5.4 +\@category Exception
Constructs a new NutsNotInstallableException exception
Constructs a new NutsNotInstallableException exception
Constructs a new NutsNotInstallableException exception
Constructs a new NutsNotInstallableException exception
This Exception is fired when an artifact fails to be uninstalled for the artifact not being installed yet.
\@since 0.5.4 +\@category Exception
Constructs a new NutsNotInstalledException exception
Constructs a new NutsNotInstalledException exception
Constructs a new NutsNotInstalledException exception
Constructs a new NutsNotInstalledException exception
Exception Thrown when for any reason, the enum value is not expected/supported. +\@author vpc +\@category Exception
create new instance of NutsUnexpectedEnumException
create new instance of NutsUnexpectedEnumException
enum type
return invalid value
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsParseException exception
Constructs a new NutsParseException exception
Constructs a new NutsParseException exception
Constructs a new NutsParseException exception
Constructs a new NutsParseException exception
Push Exception
\@since 0.5.4 +\@category Exception
Constructs a new NutsPushException exception
Constructs a new NutsPushException exception
Constructs a new NutsPushException exception
Constructs a new NutsPushException exception
Constructs a new NutsPushException exception
Constructs a new NutsPushException exception
artifact id
Created by vpc on 1/15/17.
\@since 0.5.4 +\@category Exception
Constructs a new NutsReadOnlyException exception
Constructs a new NutsReadOnlyException exception
This exception is thrown when a repository location could no be loaded because +the repository is already registered for the actual workspace. +\@since 0.5.4 +\@category Exception
Constructs a new NutsNotInstalledException exception
Constructs a new NutsNotInstalledException exception
Base exception for Repository related exceptions
\@since 0.5.4 +\@category Exception
Constructs a new NutsRepositoryException exception
the repository of this exception
This exception is thrown when a repository location could no be loaded because +the repository config files are missing.
\@since 0.5.4 +\@category Exception
Constructs a new NutsRepositoryNotFoundException exception
Thrown by Nuts Workspace to indicate a security violation. +\@since 0.5.4 +\@category Exception
Constructs a \<code>NutsSecurityException\</code> with the specified +parameters.
Constructs a \<code>NutsSecurityException\</code> with the specified +parameters.
Constructs a \<code>NutsSecurityException\</code> with the specified +parameters.
Constructs a \<code>NutsSecurityException\</code> with the specified +parameters.
current workspace
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsTooManyElementsException exception
Constructs a new NutsTooManyElementsException exception
Constructs a new NutsTooManyElementsException exception
Constructs a new NutsTooManyElementsException exception
Constructs a new NutsTooManyElementsException exception
Constructs a new NutsTooManyElementsException exception
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsUnexpectedException exception
Constructs a new NutsUnexpectedException exception
Constructs a new NutsUnexpectedException exception
Constructs a new NutsUnexpectedException exception
Constructs a new NutsUnexpectedException exception
Constructs a new NutsUnexpectedException exception
This Exception is thrown when an artifact fails to be uninstalled
\@since 0.5.4 +\@category Exception
Custom Constructor
Custom Constructor
Custom Constructor
Custom Constructor
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsUnsatisfiedRequirementsException exception
Constructs a new NutsUnsatisfiedRequirementsException exception
Constructs a new NutsUnsatisfiedRequirementsException exception
Constructs a new NutsUnsatisfiedRequirementsException exception
Constructs a new NutsUnsatisfiedRequirementsException exception
Constructs a new NutsUnsatisfiedRequirementsException exception
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsUnsupportedArgumentException exception
Constructs a new NutsUnsupportedArgumentException exception
Constructs a new NutsUnsupportedArgumentException exception
Constructs a new NutsUnsupportedArgumentException exception
Constructs a new NutsUnsupportedArgumentException exception
Exception Thrown when for any reason, the enum value is not expected/supported.
\@author vpc +\@category Exception
create new instance of NutsUnexpectedEnumException
create new instance of NutsUnexpectedEnumException
create new instance of NutsUnexpectedEnumException
enum value
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsUnsupportedOperationException exception
Constructs a new NutsUnsupportedOperationException exception
Constructs a new NutsUnsupportedOperationException exception
Constructs a new NutsUnsupportedOperationException exception
Constructs a new NutsUnsupportedOperationException exception
\@author vpc +\@since 0.5.4 +\@category Exception
Constructs a new NutsUserCancelException exception
Constructs a new NutsUserCancelException exception
Constructs a new NutsUserCancelException exception
\@author vpc +\@since 0.5.5 +\@category Exception
Constructs a new NutsValidationException exception
Constructs a new NutsValidationException exception
Constructs a new NutsValidationException exception
Constructs a new NutsValidationException exception
Constructs a new NutsValidationException exception
Constructs a new NutsValidationException exception
Created by vpc on 1/15/17.
\@since 0.5.4 +\@category Exception
Constructs a new NutsWorkspaceAlreadyExistsException exception
Constructs a new NutsWorkspaceAlreadyExistsException exception
workspace location
NutsWorkspaceException is the base class for Workspace related exceptions.
\@since 0.5.4 +\@category Exception
Constructs a new NutsWorkspaceException exception
This Exception is thrown when the workspace does not exist.
\@since 0.5.4 +\@category Exception
Constructs a new NutsWorkspaceNotFoundException exception
workspace location
\@author vpc +\@category Extensions
return:boolean
return:boolean
return:NutsContent
return:NutsDescriptor
return:Iterator
return:NutsId
return:Iterator
Created by vpc on 1/15/17.
\@since 0.5.4 +\@category Extensions
extension id pattern (configured)
extension id resolved and wired
\@author vpc +\@since 0.5.4 +\@category Extensions
return loaded extensions
return:List
return:List
return:NutsServiceLoader
return:NutsServiceLoader
create supported extension implementation or return null.
return:NutsComponent
create supported extension implementation or return null.
return:NutsComponent
return:List
return:boolean
return:boolean
return:boolean
Dependency Format Helper +\@author vpc +\@since 0.5.6 +\@category Format
if true omit (do not include) name space when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) name space when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) name space when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) face when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) face when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) group when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) group (if the group is imported) when formatting the value +set using {\@link #setValue(NutsDependency)} .
omit imported group
if true omit (do not include) namespace when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) face when formatting the value +set using {\@link #setValue(NutsDependency)} .
if true omit (do not include) query (scope and optional) when formatting the value +set using {\@link #setValue(NutsDependency)} .
list of all omitted query properties
if true omit (do not include) face when formatting the value +set using {\@link #setValue(NutsDependency)} .
update session
value dependency to format
return mutable id builder instance initialized with {\@code this} instance.
return:NutsDependencyBuilder
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsDependencyFormat
return true if omit query property named {\@code name}
return:boolean
parse dependency in the form +namespace://group:name#version?scope=<scope>{\@code &}optional=<optional> +If the string cannot be evaluated, return null.
return:NutsDependency
parse dependency in the form +namespace://group:name#version?scope=<scope>{\@code &}optional=<optional> +If the string cannot be evaluated, return null.
return:NutsDependency
if true omit (do not include) query property named {\@code name} when formatting the value +set using {\@link #setValue(NutsDependency)} .
return:NutsDependencyFormat
Descriptor Format class that help building, formatting and parsing Descriptors. +\@author vpc +\@since 0.5.4 +\@category Format
value compact flag. +When true, formatted Descriptor will compact JSON result.
create executor builder.
return:NutsArtifactCallBuilder
create classifier mappings builder.
return:NutsClassifierMappingBuilder
value compact flag to true. +When true, formatted Descriptor will compact JSON result.
return:NutsDescriptorFormat
value compact flag. +When true, formatted Descriptor will compact JSON result.
return:NutsDescriptorFormat
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsDescriptorFormat
create descriptor builder.
return:NutsDescriptorBuilder
create descriptor builder.
return:NutsIdLocationBuilder
parse descriptor.
return:NutsDescriptor
parse descriptor.
return:NutsDescriptor
parse descriptor.
return:NutsDescriptor
parse descriptor.
return:NutsDescriptor
parse descriptor.
return:NutsDescriptor
parse descriptor.
return:NutsDescriptor
set the descriptor instance to print
return:NutsDescriptorFormat
Class responsible of manipulating {\@link NutsElement} type. It help parsing +from, converting to and formatting such types.
\@author vpc +\@since 0.5.5 +\@category Format
set current session.
set current value to format.
element builder
return:NutsElementBuilder
compile pathExpression into a valid NutsElementPath that helps filtering +elements tree. +JSONPath expressions refer to a JSON structure the same way as XPath expression are used with XML documents. +JSONPath expressions can use the dot notation and/or bracket notations +.store.book[0].title +The trailing root is not necessary : +.store.book[0].title +You can also use bracket notation +store[\'book\'][0].title +for input paths.
return:NutsElementPath
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) +} +to help return a more specific return type;
return:NutsElementFormat
convert element to the specified object if applicable or throw an +exception.
return:Object
set current value to format.
return:NutsElementFormat
convert any object to valid {\@link NutsElement}.
return:NutsElement
Format used to format command line by {\@link NutsExecCommand}
\@author vpc +\@see NutsExecCommand#format() +\@since 0.5.4 +\@category Format
set arg filter
set arg replacer
set env filter
set env replacer
if true error redirection is displayed
if true input redirection is displayed
if true output redirection is displayed
set value to format
set value to format
return:NutsExecCommandFormat
Base Format Interface used to print "things". +\@author vpc +\@since 0.5.5 +\@category Format
update session
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) +} +to help return a more specific return type;
return:NutsFormat
format current value and return the string result
return:String
format current value and write result to {\@code getSession().out()}.
format current value and write result to {\@code out}
format current value and write result to {\@code out}
format current value and write result to {\@code out}
format current value and write result to {\@code out}
format current value and write result to {\@code out}
format current value and write result to {\@code terminal}
format current value and write result to {\@code getSession().out()} and +finally appends a new line.
format current value and write result to {\@code out} and finally appends +a new line.
format current value and write result to {\@code out} and finally appends +a new line.
format current value and write result to {\@code out} and finally appends +a new line.
format current value and write result to {\@code out} and finally appends +a new line.
format current value and write result to {\@code terminal} and finally appends +a new line.
equivalent to {\@link #format() }
return:String
Class responsible of manipulating {\@link NutsId} instances: +\<ul> +\<li>formatting (in Nuts Stream Format)\</li> +\<li>parsing\</li> +\</ul> +\@author vpc +\@since 0.5.4 +\@category Format
update highlightImportedGroupId
update highlightOptional
update highlightScope
if true omit (do not include) face when formatting the value +set using {\@link #setValue(NutsId)} .
update omitFace
update omitGroup
update omitImportedGroupId
update omitNamespace
update omitOtherProperties
query properties omitted
update session
id to format
create new instance of id builder
return:NutsIdBuilder
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsIdFormat
update highlightImportedGroupId to true
return:NutsIdFormat
update highlightImportedGroupId
return:NutsIdFormat
update highlightOptional tot true
return:NutsIdFormat
update highlightOptional
return:NutsIdFormat
update highlightScope to true
return:NutsIdFormat
update highlightScope
return:NutsIdFormat
return true if omit query property named {\@code name}
return:boolean
omit scope
return:NutsIdFormat
if true omit (do not include) face when formatting the value +set using {\@link #setValue(NutsId)} .
return:NutsIdFormat
update omitFace to true
return:NutsIdFormat
update omitFace
return:NutsIdFormat
update omitGroup to true
return:NutsIdFormat
update omitGroup
return:NutsIdFormat
update omitImportedGroupId to ture
return:NutsIdFormat
update omitImportedGroupId
return:NutsIdFormat
update omitNamespace to true
return:NutsIdFormat
update omitNamespace
return:NutsIdFormat
update omitOtherProperties to true
return:NutsIdFormat
update omitOtherProperties
return:NutsIdFormat
omit query property named {\@code name}
return:NutsIdFormat
if true omit (do not include) query property named {\@code name} when formatting the value +set using {\@link #setValue(NutsId)} .
return:NutsIdFormat
parse id or null if not valid. +id is parsed in the form +namespace://group:name#version?key=<value>{\@code &}key=<value> ...
return:NutsId
parse id or error if not valid
return:NutsId
detect nuts id from resources containing the given class +or null if not found. If multiple resolutions return the first.
return:NutsId
detect all nuts ids from resources containing the given class.
return:NutsId[]
id to format
return:NutsIdFormat
if true omit (do not include) query property named {\@code name} when formatting the value +set using {\@link #setValue(NutsId)} .
return:NutsIdFormat
set id to format
return:NutsIdFormat
this class is responsible of displaying general information about the current workspace and repositories. +It is invoked by the "info" standard commmad, +\@author vpc +\@since 0.5.4 +\@category Format
enable fancy (custom, pretty) display mode
update session
enable or disable display of all repositories information
include custom properties from the given map
return:NutsInfoFormat
include a custom property
return:NutsInfoFormat
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsInfoFormat
enable display of all repositories information
return:NutsInfoFormat
enable or disable display of all repositories information
return:NutsInfoFormat
This class handles formatting of iterable items in Search. +\@author vpc +\@since 0.5.5 +\@category Format
Current output format
called at the iteration completing
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsIterableFormat
called at each new item visited
called at the iteration start
Classes implementing this interface are responsible of printing objects in multiple format +using {\@link NutsIterableFormat}. +TODO : should merge with NutsIterableFormat +\@author vpc +\@since 0.5.5 +\@category Format
configure out c
configure session
called at the iteration completing
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsIterableOutput
called at the each visited item
configure out stream
return:NutsIterableOutput
configure out stream
return:NutsIterableOutput
called at the iteration start
Implementation of this interface will provide +simple mechanism to write json text from given object. +\@author vpc +\@since 0.5.5 +\@category Format
enable or disable compact json
update session
return value to format
enable compact json
return:NutsJsonFormat
enable or disable compact json
return:NutsJsonFormat
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) +} +to help return a more specific return type;
return:NutsJsonFormat
parse bytes as a valid object of the given type
return:Object
parse file as a valid object of the given type
return:Object
parse file as a valid object of the given type
return:Object
parse inputStream as a valid object of the given type
return:Object
parse inputStream as a valid object of the given type
return:Object
parse reader as a valid object of the given type
return:Object
parse url as a valid object of the given type
return:Object
return:NutsJsonFormat
Mutable Table Model +\@author vpc +\@category Format
add row cell
return:NutsMutableTableModel
add row cells
return:NutsMutableTableModel
add header cell
return:NutsMutableTableModel
add header cells
return:NutsMutableTableModel
add row cells
return:NutsMutableTableModel
clear header
return:NutsMutableTableModel
add new row to the model
return:NutsMutableTableModel
update cell colspan
return:NutsMutableTableModel
update cell rowspan
return:NutsMutableTableModel
update cell at the given position
return:NutsMutableTableModel
update header colspan
return:NutsMutableTableModel
update header value
return:NutsMutableTableModel
Named Element +\@author vpc +\@category Format
element name
element value
Builder for manipulating {\@link NutsObjectElement} instances +\@author vpc +\@category Format
set all properties from the given {\@code other} instance. +all properties not found in {\@code other} will be retained.
return:NutsObjectElementBuilder
set all properties from the given {\@code other} instance. +all properties not found in {\@code other} will be retained.
return:NutsObjectElementBuilder
create a immutable instance of {\@link NutsObjectElement} representing +this builder.
return:NutsObjectElement
object (key,value) attributes
return:Collection
remove all properties
return:NutsObjectElementBuilder
return value for name or null. +If multiple values are available return any of them.
return:NutsElement
remove property
return:NutsObjectElementBuilder
set all properties from the given {\@code other} instance. +all properties not found in {\@code other} will be removed.
return:NutsObjectElementBuilder
set all properties from the given {\@code other} instance. +all properties not found in {\@code other} will be removed.
return:NutsObjectElementBuilder
set value for property {\@code name}
return:NutsObjectElementBuilder
element count
return:int
Object format is responsible of formatting to terminal +a given object. Multiple implementation should be available +to support tables, trees, json, xml,... +\@author vpc +\@category Format
update session
set value to format
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsObjectFormat
set value to format
return:NutsObjectFormat
Formats supported by Nuts +\@author vpc +\@since 0.5.4 +\@category Format
return:NutsOutputFormat
return:NutsOutputFormat[]
lower cased identifier.
return:String
Text align constants
\@author vpc +\@since 0.5.5 +\@category Format
return:NutsPositionType
return:NutsPositionType[]
lower cased identifier.
return:String
Class formatting Map/Properties objects +\@category Format
set model to format
set key/value separator
update session
enable/disable key sorting
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) +} +to help return a more specific return type;
return:NutsPropertiesFormat
set model to format
return:NutsPropertiesFormat
set key/value separator
return:NutsPropertiesFormat
enable key sorting
return:NutsPropertiesFormat
enable/disable key sorting
return:NutsPropertiesFormat
\@author vpc +\@since 0.5.4 +\@category Format
return:String
\@author vpc +\@category Format
return:boolean
return:int
return:String
Class responsible of formatting a formatted string.
\@author vpc +\@since 0.5.5 +\@category Format
set current session.
set current value to format.
return:NutsStringFormat
return:NutsStringFormat
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, String...) +} +to help return a more specific return type;
return:NutsStringFormat
return:NutsStringFormat
set current value to format.
return:NutsStringFormat
return:NutsStringFormat
return:NutsStringFormat
return:NutsStringFormat
return:NutsStringFormat
\@since 0.5.5 +\@category Format
return:String
\@author vpc +\@since 0.5.5 +\@category Format
return:NutsTableCell
return:NutsTableCell
return:NutsTableCell
\@author vpc +\@since 0.5.5 +\@category Format
return:String
\@author vpc +\@since 0.5.5 +\@category Format
update session
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsTableFormat
return:NutsMutableTableModel
return:NutsTableFormat
return:NutsTableFormat
return:NutsTableFormat
return:NutsTableFormat
return:NutsTableFormat
return:NutsTableFormat
\@author vpc +\@since 0.5.5 +\@category Format
Filtered Terminal Format Helper
\@see NutsIOManager#getTerminalFormat() +\@see NutsWorkspace#io() +\@author vpc +\@since 0.5.5 +\@category Format
This method escapes all special characters that are interpreted by +"nuts print format" o that this exact string is printed on +such print streams When str is null, an empty string is return
return:String
this method removes all special "nuts print format" sequences support +and returns the raw string to be printed on an +ordinary {\@link PrintStream}
return:String
format string. supports {\@link Formatter#format(java.lang.String, java.lang.Object...) +} +pattern format and adds NutsString special format to print unfiltered strings.
return:String
format string. supports {\@link Formatter#format(java.util.Locale, java.lang.String, java.lang.Object...) +} +pattern format and adds NutsString special format to print unfiltered strings.
return:String
true if the stream is not null and could be resolved as Formatted Output +Stream. If False is returned this does no mean necessarily that the +stream is not formatted.
return:boolean
true if the stream is not null and could be resolved as Formatted Output +Stream. If False is returned this does no mean necessarily that the +stream is not formatted.
return:boolean
prepare PrintStream to handle NutsString aware format pattern. If the instance +already supports Nuts specific pattern it will be returned unmodified.
return:PrintStream
prepare PrintWriter to handle %N (escape) format pattern. If the instance +already supports Nuts specific pattern it will be returned unmodified.
return:PrintWriter
return:int
\@author vpc +\@category Format
return:NutsTextFormatStyle
return:NutsTextFormatStyle[]
Tree Format handles terminal output in Tree format. +It is one of the many formats supported bu nuts such as plain,table, xml, json. +To use Tree format, given an instance ws of Nuts Workspace you can : +\<pre> +ws. +\</pre> +\@author vpc +\@since 0.5.5 +\@category Format
update link format
update tree model
update node format
update session
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsTreeFormat
update link format
return:NutsTreeFormat
update tree model
return:NutsTreeFormat
update node format
return:NutsTreeFormat
Format class responsible of formatting prefix of a tree +\@author vpc +\@since 0.5.5 +\@category Format
return prefix for node child for the given layout
return:String
return prefix for node root for the given layout
return:String
Tree Model to use in tree format +\@author vpc +\@since 0.5.5 +\@category Format
tree node
return children of the given {\@code node}
return:List
classes implementing this interface handle formatting of the tree node. +\@author vpc +\@since 0.5.5 +\@category Format
format (transform to rich string) object at the given depth
return:String
\@author vpc +\@since 0.5.4 +\@category Format
update session
set version to print. if null, workspace version will be considered.
return true if version is null (default). In such case, workspace version +is considered.
return:NutsVersionFormat
return:NutsVersionFormat
return version instance representing the {\@code version} string
return:NutsVersion
\@author vpc +\@category Format
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:boolean
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:int
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:NutsWorkspaceOptionsFormat
return:String
Xml Format Helper class +\@author vpc +\@since 0.5.5 +\@category Format
if true compact xml generated. if false, sue more versatile/formatted output.
update session
set value to format
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) +} +to help return a more specific return type;
return:NutsXmlFormat
convert {\@code xmlElement} to a valid instance of type {\@code clazz}
return:Object
parse bytes as xml to the given class
return:Object
Parse Xml Content as given class type.
return:Object
parse inputStream as xml to the given class
return:Object
Parse Xml Content as given class type.
return:Object
Parse Xml Content as given class type.
return:Object
parse url content as xml to the given class
return:Object
convert {\@code value} to an xml document.
return:Document
convert {\@code value} to a valid root element to add to the given {\@code xmlDocument}. +if the document is null, a new one will be created.
return:Element
set value to format
return:NutsXmlFormat
I/O Action that help monitored copy of one or multiple resource types. +Implementation should at least handle the following types as valid sources : +\<ul> +\<li>InputStream\</li> +\<li>string (as path or url)\</li> +\<li>File (file or directory)\</li> +\<li>Path (file or directory)\</li> +\<li>URL\</li> +\</ul> +and the following types as valid targets : +\<ul> +\<li>OutputStream\</li> +\<li>string (as path or url)\</li> +\<li>File (file or directory)\</li> +\<li>Path (file or directory)\</li> +\</ul> +\@author vpc +\@since 0.5.4 +\@category Input Output
run this copy action with {\@link java.io.ByteArrayOutputStream} target and return bytes result
mark created stream as interruptible so that one can call {\@link #interrupt()}
switch log progress flag to {\@code value}.
set progress monitor. Will create a singleton progress monitor factory
set progress factory responsible of creating progress monitor
switch safe copy flag to {\@code value}
update current session
set skip root flag to {\@code value}
update source to copy from
update target to copy from
update validator
update source to copy from
return:NutsIOCopyAction
update source to copy from
return:NutsIOCopyAction
update source to copy from
return:NutsIOCopyAction
update source to copy from
return:NutsIOCopyAction
update source to copy from
return:NutsIOCopyAction
update source to copy from
return:NutsIOCopyAction
interrupt last created stream. An exception is throws when the stream is read.
return:NutsIOCopyAction
switch log progress flag to to true.
return:NutsIOCopyAction
switch log progress to {\@code value}
return:NutsIOCopyAction
set progress monitor. Will create a singleton progress monitor factory
return:NutsIOCopyAction
set progress factory responsible of creating progress monitor
return:NutsIOCopyAction
run this copy action
return:NutsIOCopyAction
arm safe copy flag
return:NutsIOCopyAction
switch safe copy flag to {\@code value}
return:NutsIOCopyAction
set skip root flag to {\@code true}
return:NutsIOCopyAction
set skip root flag to {\@code value}
return:NutsIOCopyAction
update target
return:NutsIOCopyAction
update target
return:NutsIOCopyAction
update target to copy from
return:NutsIOCopyAction
update target to copy from
return:NutsIOCopyAction
update target to copy from
return:NutsIOCopyAction
update validator
return:NutsIOCopyAction
classes implementing this interface should check the validity of the stream that was copied. +\@since 0.5.8 +\@category Input Output
Check the validity of the stream that was copied.
I/O Action that help monitored delete.
\@author vpc +\@since 0.5.8 +\@category Input Output
update fail fast flag
update session
update target to delete
set fail fast flag
return:NutsIODeleteAction
update fail fast flag
return:NutsIODeleteAction
run delete action and return {\@code this}
return:NutsIODeleteAction
update target to delete
return:NutsIODeleteAction
I/O command to hash contents. +\@author vpc +\@since 0.5.5 +\@category Input Output
select hash algorithm.
select hash algorithm.
return:NutsIOHashAction
compute hash digest and return it as byte array
return:byte[]
compute hash digest and return it as hexadecimal string
return:String
select MD5 hash algorithm
return:NutsIOHashAction
select MD5 hash algorithm
return:NutsIOHashAction
source stream to hash
return:NutsIOHashAction
file to hash
return:NutsIOHashAction
source stream to hash
return:NutsIOHashAction
file to hash
return:NutsIOHashAction
compute hash and writes it to the output stream
return:NutsIOHashAction
Lock builder to create mainly File based Locks +\@author vpc +\@since 0.5.8 +\@category Input Output
update resource
update session
update source
create lock object for the given source and resource
return:Object
create lock object for the given source and resource
return:Object
create lock object for the given source and resource
return:NutsLock
update resource
return:NutsIOLockAction
create lock object for the given source and resource
create lock object for the given source and resource
update source
return:NutsIOLockAction
I/O Manager supports a set of operations to manipulate terminals and files in a +handy manner that is monitorable and Workspace aware.
\@author vpc +\@since 0.5.4 +\@category Input Output
update workspace wide system terminal
update workspace wide terminal
return terminal format that handles metrics and format/escape methods.
create new {\@link NutsIOCompressAction} instance
return:NutsIOCompressAction
create new {\@link NutsIOCopyAction} instance
return:NutsIOCopyAction
create a new instance of {\@link NutsApplicationContext}
return:NutsApplicationContext
create print stream that supports the given {\@code mode}. +If the given {\@code out} is a PrintStream that supports {\@code mode}, it should be +returned without modification.
return:PrintStream
create temp file in the workspace\'s temp folder
return:Path
create temp file in the repository\'s temp folder
return:Path
create temp folder in the workspace\'s temp folder
return:Path
create temp folder in the repository\'s temp folder
return:Path
return new terminal bound to system terminal
return:NutsSessionTerminal
return new terminal bound to the given {\@code parent}
return:NutsSessionTerminal
create new {\@link NutsIODeleteAction} instance
return:NutsIODeleteAction
return non null executor service
return:ExecutorService
expand path to Workspace Location
return:String
expand path to {\@code baseFolder}. +Expansion mechanism supports \'~\' prefix (linux like) and will expand path to {\@code baseFolder} +if it was resolved as a relative path.
return:String
create new {\@link NutsIOHashAction} instance that helps +hashing streams and files.
return:NutsIOHashAction
load resource as a formatted string to be used mostly as a help string.
return:String
load resource as a formatted string to be used mostly as a help string.
return:String
create new {\@link NutsIOLockAction} instance
return:NutsIOLockAction
create new {\@link NutsMonitorAction} instance that helps +monitoring streams.
return:NutsMonitorAction
create a null input stream instance
return:InputStream
create a null print stream instance
return:PrintStream
parse Execution Entries
return:NutsExecutionEntry[]
parse Execution Entries
return:NutsExecutionEntry[]
parse Execution Entries
return:NutsExecutionEntry[]
create new {\@link NutsIOProcessAction} instance
return:NutsIOProcessAction
return terminal format that handles metrics and format/escape methods.
return:NutsSystemTerminal
return workspace default terminal
return:NutsSessionTerminal
return terminal format that handles metrics and format/escape methods
return:NutsTerminalFormat
create new {\@link NutsIOUncompressAction} instance
return:NutsIOUncompressAction
I/O Action that help monitoring processes
\@author vpc +\@since 0.5.8 +\@category Input Output
update fail fast flag
list all processes of type {\@link #getType()}
update session
set process type to consider. +Supported \'java\' or \'java#version\'
set fail fast flag
return:NutsIOProcessAction
update fail fast flag
return:NutsIOProcessAction
set process type to consider. +Supported \'java\' or \'java#version\'
return:NutsIOProcessAction
I/O Action that help monitored uncompress of one or multiple resource types. +\@author vpc +\@since 0.5.8 +\@category Input Output
update format
switch log progress flag to {\@code value}.
set progress monitor. Will create a singleton progress monitor factory
set progress factory responsible of creating progress monitor
switch safe flag to {\@code value}
update current session
set skip root flag to {\@code value}
update source to uncompress from
update target
update source to uncompress from
return:NutsIOUncompressAction
update source to uncompress from
return:NutsIOUncompressAction
update source to uncompress from
return:NutsIOUncompressAction
update source to uncompress from
return:NutsIOUncompressAction
update source to uncompress from
return:NutsIOUncompressAction
update source to uncompress from
return:NutsIOUncompressAction
return format option
return:Object
switch log progress flag to to true.
return:NutsIOUncompressAction
switch log progress flag to {\@code value}.
return:NutsIOUncompressAction
set progress monitor. Will create a singleton progress monitor factory
return:NutsIOUncompressAction
set progress factory responsible of creating progress monitor
return:NutsIOUncompressAction
run this uncompress action
return:NutsIOUncompressAction
arm safe flag
return:NutsIOUncompressAction
switch safe flag to {\@code value}
return:NutsIOUncompressAction
update format option
return:NutsIOUncompressAction
set skip root flag to {\@code true}
return:NutsIOUncompressAction
set skip root flag to {\@code value}
return:NutsIOUncompressAction
update target
return:NutsIOUncompressAction
update target
return:NutsIOUncompressAction
update target
return:NutsIOUncompressAction
update target
return:NutsIOUncompressAction
NutsLock is simply an adapter to standard {\@link Lock}. +It adds no extra functionality but rather is provided as +a base for future changes. +\@since 0.5.8 +\@category Input Output
Monitor action enables monitoring a long lasting operation such as copying a big file.
\@author vpc +\@category Input Output
update operation length
when true, will include default factory (console) even if progressFactory is defined
update action name
update action source origin
set progress factory responsible of creating progress monitor
set progress monitor. Will create a singleton progress monitor factory
update current session
update operation source
Create monitored input stream
return:InputStream
update operation length
return:NutsMonitorAction
will include default factory (console) even if progressFactory is defined
return:NutsMonitorAction
when true, will include default factory (console) even if progressFactory is defined
return:NutsMonitorAction
update action name
return:NutsMonitorAction
update action source origin
return:NutsMonitorAction
set progress factory responsible of creating progress monitor
return:NutsMonitorAction
set progress monitor. Will create a singleton progress monitor factory
return:NutsMonitorAction
update operation source
return:NutsMonitorAction
update operation source
return:NutsMonitorAction
update operation source
return:NutsMonitorAction
update operation source +TODO: should this handle only streams?
return:NutsMonitorAction
Non formatted Print Stream Anchor Interface +\@author vpc +\@since 0.5.4 +\@category Input Output
Interface to enable marking system streams. When creating new processes nuts +will dereference NutsOutputStreamTransparentAdapter to check if the +OutputStream i a system io. In that cas nuts will "inherit" output/error +stream
\@since 0.5.4 +\@category Input Output
de-referenced stream
return:OutputStream
\@author vpc +\@since 0.5.4 +\@category Input Output
A Terminal handles in put stream, an output stream and an error stream to communicate +with user. +\@since 0.5.4 +\@category Input Output
change terminal mode for err
change terminal mode for both out and err
change terminal mode for out
create a {\@link NutsQuestion} to write a question to the terminal\'s output stream +and read a typed value from the terminal\'s input stream.
return:NutsQuestion
return terminal\'s error stream
return:PrintStream
change terminal mode for out
return:NutsTerminal
return terminal\'s input stream
return:InputStream
change terminal mode for both out and err
return:NutsTerminal
return terminal\'s output stream
return:PrintStream
change terminal mode for out
return:NutsTerminal
Reads a single line of text from the terminal\'s input stream.
return:String
Reads password as a single line of text from the terminal\'s input stream.
return:char[]
\@author vpc +\@category Internal
log configuration for running nuts +\@author vpc +\@since 0.5.4 +\@category Logging
return:boolean
return:int
return:NutsLogConfig
return:NutsLogConfig
return:NutsLogConfig
return:NutsLogConfig
return:NutsLogConfig
return:NutsLogConfig
return:NutsLogConfig
return:String
Nuts Log Manager +\@category Logging
file handler
return file logger level
Log handler
terminal handler
return terminal logger level
add the given handler
create an instance of {\@link NutsLogger}
return:NutsLogger
create an instance of {\@link NutsLogger}
return:NutsLogger
remove the given handler
set file logger level
set terminal logger level
Workspace aware Logger +\@category Logging
Check if a message of the given level would actually be logged +by this logger. This check is based on the Loggers effective level, +which may be inherited from its parent.
return:boolean
Log a LogRecord. +\<p> +All the other logging methods in this class call through +this method to actually perform any logging. Subclasses can +override this single method to capture all log activity.
log message using \'FAIL\' verb
log message using the given verb and level
log message using the given verb and level
log message using the given verb and level
create a logger op. +A Logger Op handles all information to log in a custom manner.
return:NutsLoggerOp
Log operation +\@category Logging
set log error
return:NutsLoggerOp
set formatted mode (Nuts Stream Format)
return:NutsLoggerOp
set or unset formatted mode (Nuts Stream Format)
return:NutsLoggerOp
set operation level
return:NutsLoggerOp
log the given message
log the given message
set message style (cstyle or positional)
return:NutsLoggerOp
set operation time
return:NutsLoggerOp
set log verb
return:NutsLoggerOp
file related constants
default folder names
Nuts Id query parameter names. Nuts id has the following form +namespace://group:name#version?query where query is in the form +key=value{\@literal \@}key=value... +\<p> +This class defines all standard key names and their default values in the +query part.
identifier related constants
name constants
standard right keys for distinct operations in nuts.
valid values for Query parameter "face"
nuts standard user names
version special names
argument entry
argument index
argument value
env entry
env name
env value
Exception thrown when copy validation fails
Constructs a new Validation Exception
Constructs a new Validation Exception
Constructs a new Validation Exception
Constructs a new Validation Exception
\@author vpc +\@since 0.5.4
return:NutsRepositoryRef
return:boolean
return:int
return:NutsRepositoryRef
return:NutsRepositoryRef
return:NutsRepositoryRef
return:NutsRepositoryRef
return:NutsRepositoryRef
return:String
\@author vpc +\@since 0.5.4
return:NutsAddUserCommand
return:NutsRepositorySecurityManager
check if the given \<code>password\</code> is valid against the one stored +by the Authentication Agent for \<code>credentialsId\</code>
store credentials in the agent\'s and return the credential id to store +into the config. if credentialId is not null, the given credentialId will +be updated and the credentialId is returned. The {\@code credentialsId},if +present or returned, \<strong>MUST\</strong> be prefixed with +AuthenticationAgent\'d id and \':\' character
return:char[]
return:NutsUser[]
get the credentials for the given id. The {\@code credentialsId} +\<strong>MUST\</strong> be prefixed with AuthenticationAgent\'d id and \':\' +character
return:char[]
remove existing credentials with the given id The {\@code credentialsId} +\<strong>MUST\</strong> be prefixed with AuthenticationAgent\'d id and \':\' +character
return:boolean
return:NutsRemoveUserCommand
return:NutsRepositorySecurityManager
return:NutsUpdateUserCommand
return:Separator
return:Separator[]
lower cased identifier.
return:String
NutsBootWorkspace is responsible of loading initial nuts-core.jar and its +dependencies and for creating workspaces using the method +{\@link #openWorkspace()} . NutsBootWorkspace is also responsible of managing +local jar cache folder located at ~/.cache/nuts/default-workspace/boot +\<p> +Default Bootstrap implementation. This class is responsible of loading +initial nuts-core.jar and its dependencies and for creating workspaces using +the method {\@link #openWorkspace()}. +\<p>
\@author vpc +\@since 0.5.4 +\@category SPI Base
return:ProcessBuilder
return:String[]
return:String
return a string representing unsatisfied contrains
return:String
return:boolean
return:NutsWorkspace
return:Collection
return:int
Class responsible of creating and initializing Workspace +Created by vpc on 1/5/17.
\@since 0.5.4 +\@category SPI Base
create workspace with the given options
return:NutsWorkspace
when multiple factories are available, the best one is selected according to +the maximum value of {\@code getBootSupportLevel(options)}. +Note that default value (for the reference implementation) is {\@code NutsComponent.DEFAULT_SUPPORT}. +Any value less or equal to zero is ignored (and the factory is discarded)
return:int
Command Alias Factory Definition Config
\@author vpc +\@since 0.5.4 +\@category SPI Base
Factory id (unique identifier in the workspace)
Factory Type
factory parameters
priority (the higher the better)
return:boolean
return:int
return:String
Top Level extension Point in Nuts. +Extension mechanism in nuts is based on a factory thats select the best +implementation for a given predefined interface (named Extension Point). +Such interfaces must extend this {\@code NutsComponent} interface. +Implementations must implement these extension points by providing their +best support level (when method {\@link #getSupportLevel(net.vpc.app.nuts.NutsSupportLevelContext)} is invoked). +Only implementations with positive support level are considered. +Implementations with higher support level are selected first.
\@param \<CriteriaType> support criteria type +\@since 0.5.4 +\@category SPI Base
evaluate support level (who much this instance should be considered convenient, acceptable) +for the given arguments (provided in context).
return:int
Default and dummy NutsSupportLevelContext implementation +\@author vpc +\@param \<T> support level type +\@category SPI Base
default constructor
return:boolean
return:int
return:String
Repository Deploy command provided by Repository and used by Workspace. +This class is part of Nuts SPI and is not to be used by end users. +\@author vpc +\@since 0.5.4 +\@category SPI Base
set content to deploy
set descriptor to deploy
set id to deploy
session
run deploy command
return:NutsDeployRepositoryCommand
Content parser component is responsible of resolving a Nuts descriptor form a content file
\@since 0.5.4 +\@category SPI Base
parse content and return a valid NutsDescriptor or null if not supported.
return:NutsDescriptor
context holding useful information for {\@link NutsDescriptorContentParserComponent#parse(NutsDescriptorContentParserContext)}
\@since 0.5.4 +\@category SPI Base
content file extension or null. At least one of file extension or file mime-type is provided.
content stream
return content header stream. +if the content size is less than 1Mb, then all the content is returned. +If not, at least 1Mb is returned.
content mime-type or null. At least one of file extension or file mime-type is provided.
content name (mostly content file name)
command line options that can be parsed to +configure parsing options. +A good example of it is the --all-mains option that can be passed +as executor option which will be catched by parser to force resolution +of all main classes even though a Main-Class attribute is visited in the MANIFEST.MF +file. +This array may continue any non supported options. They should be discarded by the parser.
return session
return workspace
An Executor Component is responsible of "executing" a nuts component +(package) Created by vpc on 1/7/17.
\@since 0.5.4 +\@category SPI Base
artifact id
performs a dry execution (simulation) avoiding any side effect and issuing trace to standard +output in order to log simulation workflow.
execute the artifact
Repository command bound to FetchCommand used to fetch an artifact content from a specific repository. +\@author vpc +\@since 0.5.5 +\@category SPI Base
set descriptor to fetch.
fetchMode
set id to fetch.
set localPath to store to.
return fetch result. if the command is not yet executed, it will be executed first.
set current session.
preform command. Should be called after setting all parameters. +Result is retrievable with {\@link #getResult()}.
return:NutsFetchContentRepositoryCommand
Repository command used to fetch an artifact descriptor from a specific repository. +\@author vpc +\@since 0.5.5 +\@category SPI Base
fetchMode
set id to fetch
return fetch result. if the command is not yet executed, it will be executed first.
preform command. Should be called after setting all parameters. +Result is retrievable with {\@link #getResult()}.
return:NutsFetchDescriptorRepositoryCommand
return:NutsFetchDescriptorRepositoryCommand
Component responsible of installing other artifacts.
\@since 0.5.4 +\@category SPI Base
install artifact
uninstall artifact
update artifact
classes that are marked with this annotation will be created at each call by +the factory.
\@since 0.5.4 +\@category SPI Base
Push Command +\@author vpc +\@category SPI Base
args args to push
set id to push.
local only (installed or not)
repository to push from
set session
run this command and return {\@code this} instance
return:NutsPushRepositoryCommand
Root class for all Repository commands. +\@author vpc +\@category SPI Base
set session
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsRepositoryCommand
run this command and return {\@code this} instance
return:NutsRepositoryCommand
Created by vpc on 1/15/17.
\@since 0.5.4 +\@category SPI Base
return:NutsRepository
\@author vpc +\@since 0.5.4 +\@category SPI Base
run this command and return {\@code this} instance
return:NutsRepositoryUndeployCommand
return:NutsRepositoryUndeployCommand
return:NutsRepositoryUndeployCommand
return:NutsRepositoryUndeployCommand
return:NutsRepositoryUndeployCommand
return:NutsRepositoryUndeployCommand
\@author vpc +\@category SPI Base
fetchMode
this method should return immediately and returns valid iterator. +visiting iterator may be blocking but not this method call. +If {\@code run()} method has not been called yet, it will be called.
this method should return immediately after initializing a valid iterator to be +retrieved by {\@code getResult()}
return:NutsSearchRepositoryCommand
return:NutsSearchRepositoryCommand
return:NutsSearchRepositoryCommand
\@author vpc +\@category SPI Base
fetchMode
run this command and return {\@code this} instance
return:NutsSearchVersionsRepositoryCommand
return:NutsSearchVersionsRepositoryCommand
return:NutsSearchVersionsRepositoryCommand
return:NutsSearchVersionsRepositoryCommand
Component service class loader. +\@author vpc +\@param \<T> component type +\@param \<B> component support constraint type +\@since 0.5.4 +\@category SPI Base
load all NutsComponent instances matching criteria
return:List
load best NutsComponent instance matching criteria
return:NutsComponent
Session Terminal Base instance are special Terminal Base classes instances that handle workspace session.
\@since 0.5.4 +\@category SPI Base
classes that are marked with this annotation will be created once by the +factory.
\@since 0.5.4 +\@category SPI Base
\@author vpc +\@category SPI Base
Created by vpc on 2/20/17.
\@since 0.5.4 +\@category SPI Base
Created by vpc on 2/20/17.
\@since 0.5.4 +\@category SPI Base
return:String
return:char[]
return:NutsTerminalBase
return:NutsTerminalBase
Transport component responsible of creating a connexion to remote servers. +Should handle at least valid http connections. +\@since 0.5.4 +\@category SPI Base
open url and return a valid {\@link NutsTransportConnection}
return:NutsTransportConnection
Connection to a remote server.
\@since 0.5.4 +\@category SPI Base
parse connection header and return meaningful information
option connection and retrieve input stream
return:InputStream
parse connection header and return meaningful information
return:InputStream
Created by vpc on 1/8/17.
\@since 0.5.4 +\@category SPI Base
return:boolean
return:int
return:String
Created by vpc on 1/8/17.
\@since 0.5.4 +\@category SPI Base
Created by vpc on 1/8/17.
\@since 0.5.4 +\@category SPI Base
return:boolean
return:int
return:String
Created by vpc on 1/8/17.
\@since 0.5.4 +\@category SPI Base
Created by vpc on 1/8/17.
\@since 0.5.4 +\@category SPI Base
return:boolean
return:int
return:String
Created by vpc on 1/8/17.
\@since 0.5.4 +\@category SPI Base
return:boolean
return:int
return:String
url header meaning ful information +\@author vpc +\@since 0.5.4 +\@category SPI Base
url content encoding
url content length (file size)
url content type (file type)
url content last modified
url value
\@author vpc +\@since 0.5.5 +\@category SPI Base
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsUpdateRepositoryStatisticsCommand
run this command and return {\@code this} instance
return:NutsUpdateRepositoryStatisticsCommand
return:NutsUpdateRepositoryStatisticsCommand
Created by vpc on 1/23/17.
\@since 0.5.4 +\@category SPI Base
classes that implement this class will have their method {\@link #setWorkspace(NutsWorkspace)} +called upon its creation (by factory) with a non {\@code null} argument to \<strong>initialize\</strong>. +They \<strong>may\</strong> accept a call with a {\@code null} +argument later to \<strong>dispose\</strong> the instance. +\@author vpc +\@category SPI Base
initialize or dispose the instance. +when workspace is not null, the instance should initialize it values +accordingly. +when workspace is null, the instance should dispose resources.
workspace initialization options.
Created by vpc on 1/23/17.
\@since 0.5.7 +\@category SPI Base
Command class for adding users to workspaces and repositories. All Command +classes have a \'run\' method to perform the operation.
\@see NutsWorkspaceSecurityManager#addUser(java.lang.String) +\@see NutsRepositorySecurityManager#addUser(java.lang.String)
\@author vpc +\@since 0.5.5 +\@category Security
return credentials
group list defined by {\@link #addGroup}, \@link {\@link #addGroups(String...)}} and \@link {\@link #addGroups(Collection)}}
return permissions
set remote credentials
set remote identity
update session
set username
add group named {\@code group} to the specified user
return:NutsAddUserCommand
add group list named {\@code groups} to the specified user
return:NutsAddUserCommand
add group list named {\@code groups} to the specified user
return:NutsAddUserCommand
add permission named {\@code permission} to the specified user
return:NutsAddUserCommand
add permissions list named {\@code permissions} to the specified user
return:NutsAddUserCommand
add permissions list named {\@code permissions} to the specified user
return:NutsAddUserCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsAddUserCommand
copy session
return:NutsAddUserCommand
remove group
return:NutsAddUserCommand
remove groups
return:NutsAddUserCommand
remove permissions
return:NutsAddUserCommand
remove permissions
return:NutsAddUserCommand
execute the command and return this instance
return:NutsAddUserCommand
an Authentication Agent is responsible of storing and retrieving credentials +in external repository (password manager, kwallet, keypads, +gnome-keyring...). And Id of the stored password is then saved as plain text +in nuts config file. +Criteria type is a string representing authentication agent id +\@author vpc +\@since 0.5.4 +\@category Security
agent id;
check if the given \<code>password\</code> is valid against the one stored +by the Authentication Agent for \<code>credentialsId\</code>
store credentials in the agent\'s and return the credential id to store +into the config. if credentialId is not null, the given credentialId will +be updated and the credentialId is returned. The {\@code credentialsId},if +present or returned, \<strong>MUST\</strong> be prefixed with +AuthenticationAgent\'d id and \':\' character
return:char[]
get the credentials for the given id. The {\@code credentialsId} +\<strong>MUST\</strong> be prefixed with AuthenticationAgent\'d id and \':\' +character
return:char[]
remove existing credentials with the given id The {\@code credentialsId} +\<strong>MUST\</strong> be prefixed with AuthenticationAgent\'d id and \':\' +character
return:boolean
Remove User Command +\@author vpc +\@category Security
update session
set username of user to remove
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsRemoveUserCommand
copy session
return:NutsRemoveUserCommand
execute the command and return this instance
return:NutsRemoveUserCommand
set username of user to remove
return:NutsRemoveUserCommand
\@author vpc +\@since 0.5.5 +\@category Security
update session
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
configure the current command with the given arguments. This is an +override of the {\@link NutsConfigurable#configure(boolean, java.lang.String...) } +to help return a more specific return type;
return:NutsUpdateUserCommand
copy session
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
execute the command and return this instance
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
return:NutsUpdateUserCommand
Workspace Security configuration manager +\@author vpc +\@since 0.5.4 +\@category Security
return true if current user has admin privileges
current user stack. +this is useful when login with multiple user identities.
current user
return true if workspace is running secure mode
create a User Create command. +No user will be added when simply calling this method. +You must fill in command parameters then call {\@link NutsAddUserCommand#run()}.
return:NutsAddUserCommand
check if allowed and throw a Security exception if not.
return:NutsWorkspaceSecurityManager
check if the given \<code>password\</code> is valid against the one stored +by the Authentication Agent for \<code>credentialsId\</code>
store credentials in the agent\'s and return the credential id to store +into the config. if credentialId is not null, the given credentialId will +be updated and the credentialId is returned. The {\@code credentialsId},if +present or returned, \<strong>MUST\</strong> be prefixed with +AuthenticationAgent\'d id and \':\' character
return:char[]
equivalent to {\@link #getCurrentLoginStack()}.
return:String[]
equivalent to {\@link #getCurrentUsername()}.
return:String
find user with the given name or null.
return:NutsUser
find all registered users
return:NutsUser[]
get authentication agent with id {\@code authenticationAgentId}. +if is blank, return default authentication agent
return:NutsAuthenticationAgent
get the credentials for the given id. The {\@code credentialsId} +\<strong>MUST\</strong> be prefixed with AuthenticationAgent\'d id and \':\' +character
return:char[]
return true if permission is valid and allowed for the current user.
return:boolean
impersonate user and log as a distinct user with the given credentials and stack +user name so that it can be retrieved using \@{code getCurrentLoginStack()}.
return:NutsWorkspaceSecurityManager
impersonate user and log as a distinct user with the given credentials.
return:NutsWorkspaceSecurityManager
log out from last logged in user (if any) and pop out from user name stack.
return:NutsWorkspaceSecurityManager
remove existing credentials with the given id The {\@code credentialsId} +\<strong>MUST\</strong> be prefixed with AuthenticationAgent\'d id and \':\' +character
return:boolean
create a Remove Create command. +No user will be removed when simply calling this method. +You must fill in command parameters then call {\@link NutsRemoveUserCommand#run()}.
return:NutsRemoveUserCommand
update default authentication agent.
return:NutsWorkspaceSecurityManager
switch from/to secure mode. +when secure mode is disabled, no authorizations are checked against.
return:boolean
create a Update Create command. +No user will be updated when simply calling this method. +You must fill in command parameters then call {\@link NutsUpdateUserCommand#run()}.
return:NutsUpdateUserCommand
You can write JSX and use React components within your Markdown thanks to MDX.
Docusaurus green and Facebook blue are my favorite colors.I can write Markdown alongside my JSX!
The Java Package Manager
![[object Object]](/nuts/img/oss.png)
Nuts Package manager is an Open Source package manager for the Java © ecosystem. Nuts is your best companion for your maven built applications.
![[object Object]](/nuts/img/install.png)
install, run and manage all the versions of your applications in parallal.
![[object Object]](/nuts/img/automate.png)
Take advantage of the Nuts toolbox that offers GNU binutils equivalent tools (bash,ls, cp, and more), and extend them to support json and xml outputs to help automation.