More content updates

Author: Jan Kleinert

workshop/content/030-deploy-an-app.md

@@ -65,7 +65,25 @@ The output will look something like this:
 
 `odo` has pushed the code into the component, built the application, and run it.
 
-To visit your application, copy the URL from the terminal window, open a new browser window and paste it into the URL address bar.
+We can tail the logs to make sure the application is up and running:
+
+```execute-1
+odo log -f
+```
+
+You're looking for this message:
+
+```
+Listening on 0.0.0.0, port 8080
+```
+
+And then run:
+
+```execute-1
+<ctrl+c>
+```
+
+To visit your application, copy the URL from the top terminal window, open a new browser window and paste it into the URL address bar.
 
 Alternatively, you can run the following command to get the URL:
 

workshop/content/040-overview.md

@@ -1,5 +1,5 @@
 ---
-Title: Application overview
+Title: Interacting with OpenShift
 PrevPage: 030-deploy-an-app
 NextPage: 050-creating-an-application
 ---
@@ -10,6 +10,8 @@ The goal for this lab is to showcase `odo` and all of its primitives and to do s
 
 Now although the intent is to show as much as possible of what `odo` can do, because of how the workshop environment works, we have skipped how you can log in to OpenShift using `odo`. In the workshop environment, you have already been logged in from the terminal window. You also have a project created for you in advance.
 
+### Authentication
+
 If you were using `odo` with your own cluster, you could log in to the cluster by using:
 
 ```bash
@@ -18,6 +20,8 @@ odo login
 
 The command will interactively prompt you for details of the cluster. Alternatively you could supply the address of the OpenShift cluster as an argument.
 
+### Projects
+
 To create, change, or delete projects, you can use the `odo project` command. Run `odo project get` to show you the name of the current project you are working in:
 
 ```execute
@@ -33,3 +37,66 @@ odo project --help
 The `--help` option can be used on any `odo` command to see more details about what it can do.
 
 Since we already have a project created for us, we are good to go though, and do not need to create one.
+
+## Component configuration and global preferences
+
+There are a couple other commands you can run to view component configuration and `odo` preferences that are global.
+
+Run this command to view the values for global `odo` preferences:
+
+```execute-1
+odo preference view
+```
+
+The preference parameters are defined as follows:
+
+
+**NamePrefix** - Default prefix is the current directory name. Use this value to set a default name prefix
+
+**Timeout** - Timeout (in seconds) for OpenShift server connection check
+
+**UpdateNotification** - Controls if an update notification is shown or not (true or false)
+
+
+To view the current component configuration, run this command:
+
+```execute-1
+odo config view
+```
+
+The component configuration parameters are defined as follows:
+
+
+**Application** - Application is the name of application the component needs to be part of
+
+**CPU** - The minimum and maximum CPU a component can consume
+
+**Ignore** - Consider the .odoignore file for push and watch
+
+**MaxCPU** - The maximum CPU a component can consume
+
+**MaxMemory** - The maximum memory a component can consume
+
+**Memory** - The minimum and maximum memory a component can consume
+
+**MinCPU** - The minimum CPU a component can consume
+
+**MinMemory** - The minimum memory a component is provided
+
+**Name** - The name of the component
+
+**Ports** - Ports to be opened in the component
+
+**Project** - Project is the name of the project the component is part of
+
+**Ref** - Git ref to use for creating component from git source
+
+**SourceLocation** - The path indicates the location of binary file or git source
+
+**SourceType** - Type of component source - git/binary/local
+
+**Type** - The type of component
+
+**Url** - URL to access the component
+
+

workshop/content/060-creating-new-binary-component.md

@@ -85,6 +85,12 @@ ComponentSettings:
   Name: frontend
 ```
 
+To view this in a more human-readable way, run:
+
+```execute-1
+odo config view
+```
+
 While we have this configuration defined, the application is not yet deployed on OpenShift.
 
 When we run `odo push`, a container will be created with the Java application server and then, since this is a binary component, your JAR file will be pushed to that container.
@@ -114,20 +120,6 @@ When the push completes, ``odo`` will display output similar to:
  ✓  Changes successfully pushed to component: frontend
 ```
 
-You can verify that the Java runtime has started your application by tailing the logs for your component:
-
-```execute-1
-odo log -f
-```
-
-Select the terminal window and enter:
-
-```execute-1
-<ctrl+c>
-```
-
-when you're finished checking out the logs.
-
 ## Component configuration
 When creating a component, some configuration will be inherited by default, but there is a way to override these defaults.
 

workshop/content/061-exposing-components-to-public.md

@@ -16,7 +16,27 @@ Similar to when we create a component, creating a URL sets that information in t
 odo push
 ```
 
-The URL created for the application will be displayed. Visit the URL in your web browser to view the application.
+Watch the logs and wait until the component is ready.
+
+```execute-2
+cd ~/frontend
+odo log -f
+```
+
+You're looking for a message like this:
+
+```
+2019-04-26 23:55:05.355  INFO 752 --- [           main] c.o.evg.roadshow.ParksMapApplication
+  : Started ParksMapApplication in 5.261 seconds (JVM running for 5.853)
+```
+
+Once you see that, execute `ctrl+c`
+
+```execute-2
+<ctrl+c>
+```
+
+The URL created for the application will be displayed in the output of the `odo push` command. Visit the URL in your web browser to view the application.
 
 http://frontend-parksmap-%project_namespace%.%cluster_subdomain%
 

workshop/content/070-deploying-component-from-source-code.md

@@ -24,6 +24,11 @@ We give this Node.js component the name ``backend``.
 odo create nodejs backend --app parksmap
 ```
 
+As we did for the ``frontend``, we'll also create a URL for the ``backend`` component.
+
+```execute-1
+odo url create backend --port 8080
+```
 With the component configuration created, you can ``push`` the Node.js source code from the current directory, ``backend``.
 
 ```execute-1
@@ -49,31 +54,19 @@ When the push completes, ``odo`` will display output similar to:
  ✓  Changes successfully pushed to component: backend
 ```
 
-Again, we can tail the logs to verify that our application is up and running:
+Again, we can look at the logs to verify that our application is up and running:
 
 ```execute-1
-odo log -f
+odo log 
 ```
 
-Select the terminal window and enter:
+You may need to run the command a few times before the app is ready. The message you need to see before continuing is:
 
-```execute-1
-<ctrl+c>
 ```
-
-when you're finished checking out the logs.
-
-Once we have our application up and running, we need to test it works. We're going to create a URL for it, as we did before for the frontend.
-
-```execute-1
-odo url create backend --port 8080
+Listening on 0.0.0.0, port 8080
 ```
 
-Then push again to create the URL on the cluster:
-
-```execute-1
-odo push
-```
+Once we have our application up and running, we need to test it works.
 
 This time we're going to test the application from command line, as it's a REST service.
 

workshop/content/075-create-a-service.md

@@ -26,32 +26,34 @@ When you don't specify any parameter to the creation of a service, you'll be int
 
 - *Which kind of service do you wish to create* Select `database` with the arrows and hit enter.
 - *Which database service class should we use* As you type `mongo` the list will be filtered. From the two available options, select `mongodb-ephemeral`
-- For the following options, just accept the defaults.
+- For the following options, accept the defaults **except** for the last question. Answer **y** to "Wait for the service to be ready".
 
 You will see something similar to this:
 
 ```bash
  odo service create
-? Which kind of service do you wish to create? database
-? Which database service class should we use? mongodb-ephemeral
+? Which kind of service do you wish to create database
+? Which database service class should we use mongodb-ephemeral
 ? Enter a value for string property DATABASE_SERVICE_NAME (Database Service Name): mongodb
 ? Enter a value for string property MEMORY_LIMIT (Memory Limit): 512Mi
 ? Enter a value for string property MONGODB_DATABASE (MongoDB Database Name): sampledb
 ? Enter a value for string property MONGODB_VERSION (Version of MongoDB Image): 3.2
 ? Provide values for non-required properties No
 ? How should we name your service  mongodb-ephemeral
- ✓  Service 'mongodb-ephemeral' was created
-Progress of the provisioning will not be reported and might take a long time.
-You can see the current status by executing 'odo service list'
+? Output the non-interactive version of the selected options No
+? Wait for the service to be ready Yes
+ ✓  Creating service
+ ✓  Waiting for service to come up
+ ✓  Service 'mongodb-ephemeral' is ready for use
 ```
 
-Now we can wait until the service is provisioned:
+Run the following to confirm that the service is provisioned:
 
 ```execute-1
 odo service list
 ```
 
-Keep re-running this command, and once provisioned, we should see similar output to this:
+You should see similar output to this:
 
 ```bash
 NAME                  TYPE                  STATUS

workshop/content/080-linking-components-to-services.md

@@ -17,7 +17,7 @@ This will inject configuration into the backend about the mongodb and restart th
 We can see when our application has been restarted by looking at the logs of the backend.
 
 ```execute-1
-odo log backend
+odo log backend -f
 ```
 
 __NOTE__: As a redeployment is happening in OpenShift, this might take some time. Check the logs until the component has successfully restarted. The message you need to see before continuing is:
@@ -26,9 +26,15 @@ __NOTE__: As a redeployment is happening in OpenShift, this might take some time
 Listening on 0.0.0.0, port 8080
 ```
 
+Then enter:
+
+```execute-1
+<ctrl+c>
+```
+
 __NOTE__: Due to a bug this is currently taking a bit longer than expected, so be patient.
 
-When the component finally restarts, you should now see a log showing the connection details to our database. We can now execute the same command we did before to load the database with data.
+When the component restarts, you should now see a log showing the connection details to our database. We can now execute the same command we did before to load the database with data.
 
 First we verify there's no data in the database:
 

workshop/content/081-change-active-component.md

@@ -8,7 +8,7 @@ Now that our backend is fully functional, we need to connect to it from our `fro
 
 As we're going to execute some actions with the `frontend` component, we need to set it as our active component.
 
-__NOTE__: In the near future, the current component will be defined by the directory you're in with your shell, just like *Git* does. For now, there's a way to get and change the current selected component to which some of this commands will relate.
+The current, or active, component is defined by the directory you're in with your shell, just as in *Git*. 
 
 To get a list of existing components within your application do:
 
@@ -25,16 +25,16 @@ ACTIVE     NAME         TYPE
            frontend     java
 ```
 
-The active component is the `backend`. You can either take one of two paths, change your active component and execute the `in-context` actions on it or we can specify to any command to which component the command is related. Let's do the former, but this is how the latter would look like.
+The active component is the `backend`. You can either take one of two paths, change to the directory for your component and execute the `in-context` actions on it or we can specify to any command to which component the command is related. Let's do the former, but this is how the latter would look like.
 
 ```bash
 odo <COMMAND> --component frontend
 ```
 
-Now to set your active component, do:
+Now to set the frontend as your active component, do:
 
 ```execute-1
-odo component set frontend
+cd ~/frontend
 ```
 
 And verify that actually it was properly set:

workshop/content/091-linking-application-components.md

@@ -16,15 +16,10 @@ __NOTE__: Here we have explicitly provided the component to which the link shoul
 
 This will inject configuration into the frontend about the backend and restart the frontend.
 
-Some components might expose multiple ports, and you need to select which one is the appropriate to use. In case you don't specify the port to use, you will see a nice warning message instructing you how to best proceed.
-
-Your frontend component will be redeployed.
-
-__NOTE__: We have found a bug in `odo` as we were testing this lab and you'll need to re-push your application again. This will be fixed in the coming week. Trust us :-D
+Now, re-push the component:
 
 ```execute-1
-cd ~/frontend
-odo push frontend
+odo push
 ```
 
 You can check the the startup logs:
@@ -46,3 +41,5 @@ Once the component has successfully been re-deployed you can see the changes in
 http://frontend-parksmap-%project_namespace%.%cluster_subdomain%
 
 You should now see a nice map showing where you can find national parks.
+
+![parksmap with data](parksmap-data.png)

workshop/content/100-making-changes-to-source-code.md

@@ -6,19 +6,13 @@ NextPage: 105-whats-next
 
 We've deployed the first version of our sample application and tested it by visiting it with a browser. Let's look at how OpenShift and ``odo`` help make it easier to iterate on that app once it's running.
 
-Let's first get back to our `nodejs backend` component.
-
-```execute-1
-odo component set backend
-```
-
-Let's also make sure we're in the right directory on the upper terminal:
+Let's first get back to our `backend` component.
 
 ```execute-1
 cd ~/backend
 ```
 
-and the lower terminal.
+Let's also make sure we're in the right directory on the lower terminal:
 
 ```execute-2
 cd ~/backend
@@ -30,7 +24,7 @@ Now we start the ``odo`` tool to ``watch`` for changes on the file system in the
 odo watch
 ```
 
-To change the displayed name for our backend, we edit the file `bin/config.js`.
+We will make a small change to the displayed name for our backend, from "National Parks" to "Worldwide National Parks". To change the displayed name for our backend, we edit the file `bin/config.js`.
 
 ```execute-1
 vi bin/config.js
@@ -56,7 +50,7 @@ Once it does, make a new query to the REST endpoint to validate it has changed.
 curl http://backend-parksmap-%project_namespace%.%cluster_subdomain%/ws/info/
 ```
 
-__NOTE__: The same bug as before also makes the watch operation missbehave and be slow. As we said before, this will be fixed in the coming week. Trust us :-D
+__NOTE__: The same bug as before also makes the watch operation be slow. As we said before, this will be fixed in the coming week. Trust us :-D
 
 Hit: