cleans up formatting using go fmt

Project: http://git-wip-us.apache.org/repos/asf/brooklyn-client/repo
Commit: http://git-wip-us.apache.org/repos/asf/brooklyn-client/commit/63d33d4a
Tree: http://git-wip-us.apache.org/repos/asf/brooklyn-client/tree/63d33d4a
Diff: http://git-wip-us.apache.org/repos/asf/brooklyn-client/diff/63d33d4a

Branch: refs/heads/master
Commit: 63d33d4aa526b4e9b3d55cc0307091e246ab4617
Parents: c817890
Author: Robert Moss <robert.m...@cloudsoftcorp.com>
Authored: Sat Feb 6 11:27:04 2016 +0000
Committer: Robert Moss <robert.m...@cloudsoftcorp.com>
Committed: Sat Feb 6 11:27:04 2016 +0000

----------------------------------------------------------------------
 api/access_control/access_control.go   |  14 +-
 api/activities/activities.go           |  30 ++--
 api/application/applications.go        |  84 +++++------
 api/catalog/catalog.go                 | 158 ++++++++++----------
 api/entities/entities.go               | 134 ++++++++---------
 api/entity_config/config.go            |  42 +++---
 api/entity_effectors/effectors.go      |  18 +--
 api/entity_policies/policies.go        |  64 ++++----
 api/entity_policy_config/config.go     |  34 ++---
 api/entity_sensors/sensors.go          |  39 +++--
 api/locations/locations.go             |  14 +-
 api/server/server.go                   |   4 +-
 api/usage/usage.go                     |   2 +-
 api/version/version.go                 |   8 +-
 app/app.go                             | 149 +++++++++----------
 br/brooklyn.go                         |  10 +-
 command/command.go                     |   2 +-
 command/supercommand.go                |   3 +-
 command_factory/factory.go             |  44 +++---
 command_runner/runner.go               |   4 +-
 commands/access.go                     |  16 +-
 commands/activity-stream.go            | 158 ++++++++++----------
 commands/activity.go                   | 223 ++++++++++++++--------------
 commands/add-catalog.go                |  16 +-
 commands/add-children.go               |  18 +--
 commands/add-location.go               |   2 +-
 commands/application.go                |  75 +++++-----
 commands/catalog-applications.go       |   2 +-
 commands/catalog-entities.go           |   2 +-
 commands/catalog-entity.go             |   2 +-
 commands/catalog-location.go           |   2 +-
 commands/catalog-locations.go          |   2 +-
 commands/catalog-policies.go           |   2 +-
 commands/catalog-policy.go             |   2 +-
 commands/catalog.go                    |  18 +--
 commands/config.go                     |  44 +++---
 commands/delete-catalog-application.go |   2 +-
 commands/delete-catalog-entity.go      |   2 +-
 commands/delete-catalog-policy.go      |   2 +-
 commands/delete.go                     |  16 +-
 commands/deploy.go                     |  48 +++---
 commands/destroy-policy.go             |  16 +-
 commands/effector.go                   |  24 +--
 commands/entity.go                     |  66 ++++----
 commands/invoke.go                     |  73 ++++-----
 commands/list.go                       |  36 ++---
 commands/locations.go                  |  18 +--
 commands/login.go                      |  16 +-
 commands/policy.go                     |  96 ++++++------
 commands/rename.go                     |  16 +-
 commands/reset-catalog.go              |   2 +-
 commands/sensor.go                     |  43 +++---
 commands/set.go                        |  16 +-
 commands/spec.go                       |  16 +-
 commands/start-policy.go               |  16 +-
 commands/stop-policy.go                |  16 +-
 commands/tree.go                       |  16 +-
 commands/utils.go                      |   9 +-
 commands/version.go                    |  18 +--
 error_handler/error.go                 |   4 +-
 io/config.go                           |  14 +-
 models/access.go                       |   2 +-
 models/applications.go                 |  62 ++++----
 models/catalog.go                      |  38 +++--
 models/policies.go                     |  18 +--
 models/version.go                      |  19 ++-
 net/net.go                             |  51 ++++---
 scope/scope.go                         |  86 +++++------
 68 files changed, 1149 insertions(+), 1169 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/access_control/access_control.go
----------------------------------------------------------------------
diff --git a/api/access_control/access_control.go 
b/api/access_control/access_control.go
index 98182a2..b938ea1 100644
--- a/api/access_control/access_control.go
+++ b/api/access_control/access_control.go
@@ -1,6 +1,6 @@
 package access_control
 
-import(
+import (
        "encoding/json"
        "fmt"
        "github.com/brooklyncentral/brooklyn-cli/models"
@@ -9,12 +9,12 @@ import(
 
 func Access(network *net.Network) (models.AccessSummary, error) {
        url := fmt.Sprintf("/v1/access")
-    var access models.AccessSummary
+       var access models.AccessSummary
 
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return access, err
-    }
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return access, err
+       }
 
        err = json.Unmarshal(body, &access)
        return access, err
@@ -27,4 +27,4 @@ func Access(network *net.Network) (models.AccessSummary, 
error) {
 //     if err != nil {
 //             error_handler.ErrorExit(err)
 //     }
-//}
\ No newline at end of file
+//}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/activities/activities.go
----------------------------------------------------------------------
diff --git a/api/activities/activities.go b/api/activities/activities.go
index ce4db1a..c3ab62c 100644
--- a/api/activities/activities.go
+++ b/api/activities/activities.go
@@ -9,11 +9,11 @@ import (
 
 func Activity(network *net.Network, activity string) (models.TaskSummary, 
error) {
        url := fmt.Sprintf("/v1/activities/%s", activity)
-    var task models.TaskSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return task, err
-    }
+       var task models.TaskSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return task, err
+       }
 
        err = json.Unmarshal(body, &task)
        return task, err
@@ -21,21 +21,21 @@ func Activity(network *net.Network, activity string) 
(models.TaskSummary, error)
 
 func ActivityChildren(network *net.Network, activity string) 
([]models.TaskSummary, error) {
        url := fmt.Sprintf("/v1/activities/%s/children", activity)
-    var tasks []models.TaskSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return tasks, err
-    }
+       var tasks []models.TaskSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return tasks, err
+       }
 
        err = json.Unmarshal(body, &tasks)
        return tasks, err
 }
 
-func ActivityStream(network *net.Network, activity, streamId string) (string,  
error) {
+func ActivityStream(network *net.Network, activity, streamId string) (string, 
error) {
        url := fmt.Sprintf("/v1/activities/%s/stream/%s", activity, streamId)
-    body, err := network.SendGetRequest(url)
-    if nil != err {
-        return "", err
-    }
+       body, err := network.SendGetRequest(url)
+       if nil != err {
+               return "", err
+       }
        return string(body), nil
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/application/applications.go
----------------------------------------------------------------------
diff --git a/api/application/applications.go b/api/application/applications.go
index 0cd6290..007706a 100644
--- a/api/application/applications.go
+++ b/api/application/applications.go
@@ -20,11 +20,11 @@ func Fetch(network *net.Network) (string, error) {
 
 func Applications(network *net.Network) ([]models.ApplicationSummary, error) {
        url := fmt.Sprintf("/v1/applications")
-    var appSummary []models.ApplicationSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return appSummary, err
-    }
+       var appSummary []models.ApplicationSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return appSummary, err
+       }
 
        err = json.Unmarshal(body, &appSummary)
        return appSummary, err
@@ -32,57 +32,57 @@ func Applications(network *net.Network) 
([]models.ApplicationSummary, error) {
 
 func Create(network *net.Network, filePath string) (models.TaskSummary, error) 
{
        url := "/v1/applications"
-    var response models.TaskSummary
-    body, err := network.SendPostFileRequest(url, filePath, "application/json")
-    if err != nil {
-        return response, err
-    }
+       var response models.TaskSummary
+       body, err := network.SendPostFileRequest(url, filePath, 
"application/json")
+       if err != nil {
+               return response, err
+       }
        err = json.Unmarshal(body, &response)
        return response, err
 }
 
 func CreateFromBytes(network *net.Network, blueprint []byte) 
(models.TaskSummary, error) {
        url := "/v1/applications"
-    var response models.TaskSummary
-    body, err := network.SendPostRequest(url, blueprint)
-    if err != nil {
-        return response, err
-    }
+       var response models.TaskSummary
+       body, err := network.SendPostRequest(url, blueprint)
+       if err != nil {
+               return response, err
+       }
        err = json.Unmarshal(body, &response)
        return response, err
 }
 
 // WIP
 func Descendants(network *net.Network, app string) (string, error) {
-       url := fmt.Sprintf("/v1/applications/%s/descendants", app) 
-       
+       url := fmt.Sprintf("/v1/applications/%s/descendants", app)
+
        body, err := network.SendGetRequest(url)
        // TODO return model
-    if nil != err {
-        return "", err
-    }
+       if nil != err {
+               return "", err
+       }
        return string(body), nil
 }
 
 // WIP
 func DescendantsSensor(network *net.Network, app, sensor string) (string, 
error) {
-       url := fmt.Sprintf("/v1/applications/%s/descendants/sensor/%s", app, 
sensor) 
-       
+       url := fmt.Sprintf("/v1/applications/%s/descendants/sensor/%s", app, 
sensor)
+
        body, err := network.SendGetRequest(url)
        // TODO return model
-    if nil != err {
-        return "", err
-    }
+       if nil != err {
+               return "", err
+       }
        return string(body), nil
 }
 
 func Tree(network *net.Network) ([]models.Tree, error) {
        url := "/v1/applications/tree"
-    var tree []models.Tree
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return tree, err
-    }
+       var tree []models.Tree
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return tree, err
+       }
 
        err = json.Unmarshal(body, &tree)
        return tree, err
@@ -90,25 +90,23 @@ func Tree(network *net.Network) ([]models.Tree, error) {
 
 func Application(network *net.Network, app string) (models.ApplicationSummary, 
error) {
        url := fmt.Sprintf("/v1/applications/%s", app)
-    var appSummary models.ApplicationSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return appSummary, err
-    }
+       var appSummary models.ApplicationSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return appSummary, err
+       }
 
        err = json.Unmarshal(body, &appSummary)
        return appSummary, err
 }
 
-
-
 func Delete(network *net.Network, application string) (models.TaskSummary, 
error) {
        url := fmt.Sprintf("/v1/applications/%s", application)
-    var response models.TaskSummary
-    body, err := network.SendDeleteRequest(url)
-    if err != nil {
-       return response, err
-    }
+       var response models.TaskSummary
+       body, err := network.SendDeleteRequest(url)
+       if err != nil {
+               return response, err
+       }
        err = json.Unmarshal(body, &response)
        return response, err
 }
@@ -123,5 +121,3 @@ func CreateLegacy(network *net.Network) (string, error) {
        // TODO return model
        return string(body), nil
 }
-
-

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/catalog/catalog.go
----------------------------------------------------------------------
diff --git a/api/catalog/catalog.go b/api/catalog/catalog.go
index 6901c8b..bf97dbd 100644
--- a/api/catalog/catalog.go
+++ b/api/catalog/catalog.go
@@ -21,11 +21,11 @@ func IconWithVersion(network *net.Network, itemId, version 
string) ([]byte, erro
 
 func GetEntityWithVersion(network *net.Network, entityId, version string) 
(models.CatalogEntitySummary, error) {
        url := fmt.Sprintf("/v1/catalog/entities/%s/%s", entityId, version)
-    var catalogEntity models.CatalogEntitySummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogEntity, err
-    }
+       var catalogEntity models.CatalogEntitySummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogEntity, err
+       }
        err = json.Unmarshal(body, &catalogEntity)
        return catalogEntity, err
 }
@@ -33,19 +33,19 @@ func GetEntityWithVersion(network *net.Network, entityId, 
version string) (model
 func DeleteEntityWithVersion(network *net.Network, entityId, version string) 
(string, error) {
        url := fmt.Sprintf("/v1/catalog/entities/%s/%s", entityId, version)
        body, err := network.SendDeleteRequest(url)
-    if err != nil {
-        return "", err
-    }
+       if err != nil {
+               return "", err
+       }
        return string(body), nil
 }
 
 func GetEntity(network *net.Network, entityId string) 
(models.CatalogEntitySummary, error) {
        url := fmt.Sprintf("/v1/catalog/entities/%s", entityId)
-    var catalogEntity models.CatalogEntitySummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogEntity, err
-    }
+       var catalogEntity models.CatalogEntitySummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogEntity, err
+       }
        err = json.Unmarshal(body, &catalogEntity)
        return catalogEntity, err
 }
@@ -53,30 +53,30 @@ func GetEntity(network *net.Network, entityId string) 
(models.CatalogEntitySumma
 func DeleteEntity(network *net.Network, entityId string) (string, error) {
        url := fmt.Sprintf("/v1/catalog/entities/%s", entityId)
        body, err := network.SendDeleteRequest(url)
-    if err != nil {
-        return "", err
-    }
+       if err != nil {
+               return "", err
+       }
        return string(body), nil
 }
 
 func GetPolicy(network *net.Network, policyId string) 
(models.CatalogItemSummary, error) {
        url := fmt.Sprintf("/v1/catalog/policies/%s", policyId)
-    var catalogItem models.CatalogItemSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogItem, err
-    }
+       var catalogItem models.CatalogItemSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogItem, err
+       }
        err = json.Unmarshal(body, &catalogItem)
        return catalogItem, err
 }
 
 func GetPolicyWithVersion(network *net.Network, policyId, version string) 
(models.CatalogItemSummary, error) {
        url := fmt.Sprintf("/v1/catalog/policies/%s/%s", policyId)
-    var catalogItem models.CatalogItemSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogItem, err
-    }
+       var catalogItem models.CatalogItemSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogItem, err
+       }
        err = json.Unmarshal(body, &catalogItem)
        return catalogItem, err
 }
@@ -84,30 +84,30 @@ func GetPolicyWithVersion(network *net.Network, policyId, 
version string) (model
 func DeletePolicyWithVersion(network *net.Network, policyId, version string) 
(string, error) {
        url := fmt.Sprintf("/v1/catalog/policies/%s/%s", policyId)
        body, err := network.SendDeleteRequest(url)
-    if err != nil {
-        return "", err
-    }
+       if err != nil {
+               return "", err
+       }
        return string(body), nil
 }
 
 func GetApplication(network *net.Network, applicationId string) 
(models.CatalogEntitySummary, error) {
        url := fmt.Sprintf("/v1/catalog/applications/%s", applicationId)
-    var catalogEntity models.CatalogEntitySummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogEntity, err
-    }
+       var catalogEntity models.CatalogEntitySummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogEntity, err
+       }
        err = json.Unmarshal(body, &catalogEntity)
        return catalogEntity, err
 }
 
 func GetApplicationWithVersion(network *net.Network, applicationId, version 
string) (models.CatalogEntitySummary, error) {
        url := fmt.Sprintf("/v1/catalog/applications/%s/%s", applicationId, 
version)
-    var catalogEntity models.CatalogEntitySummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogEntity, err
-    }
+       var catalogEntity models.CatalogEntitySummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogEntity, err
+       }
        err = json.Unmarshal(body, &catalogEntity)
        return catalogEntity, err
 }
@@ -115,30 +115,30 @@ func GetApplicationWithVersion(network *net.Network, 
applicationId, version stri
 func DeleteApplicationWithVersion(network *net.Network, applicationId, version 
string) (string, error) {
        url := fmt.Sprintf("/v1/catalog/applications/%s/%s", applicationId, 
version)
        body, err := network.SendDeleteRequest(url)
-    if err != nil {
-        return "", err
-    }
+       if err != nil {
+               return "", err
+       }
        return string(body), nil
 }
 
 func Policies(network *net.Network) ([]models.CatalogPolicySummary, error) {
        url := "/v1/catalog/policies"
-    var policies []models.CatalogPolicySummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return policies, err
-    }
+       var policies []models.CatalogPolicySummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return policies, err
+       }
        err = json.Unmarshal(body, &policies)
        return policies, err
 }
 
 func Locations(network *net.Network) (models.CatalogLocationSummary, error) {
        url := "/v1/catalog/locations"
-    var catalogLocation models.CatalogLocationSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogLocation, err
-    }
+       var catalogLocation models.CatalogLocationSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogLocation, err
+       }
        err = json.Unmarshal(body, &catalogLocation)
        return catalogLocation, err
 }
@@ -155,61 +155,61 @@ func AddCatalog(network *net.Network, filePath string) 
(string, error) {
 func Reset(network *net.Network) (string, error) {
        url := "/v1/catalog/reset"
        body, err := network.SendEmptyPostRequest(url)
-    if err != nil {
-        return "", err
-    }
+       if err != nil {
+               return "", err
+       }
        return string(body), nil
 }
 
 func GetLocationWithVersion(network *net.Network, locationId, version string) 
(models.CatalogLocationSummary, error) {
        url := fmt.Sprintf("/v1/catalog/locations/%s/%s", locationId, version)
-    var catalogLocation models.CatalogLocationSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogLocation, err
-    }
+       var catalogLocation models.CatalogLocationSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogLocation, err
+       }
        err = json.Unmarshal(body, &catalogLocation)
        return catalogLocation, err
 }
 
-func PostLocationWithVersion(network *net.Network, locationId, version string) 
(string, error)  {
+func PostLocationWithVersion(network *net.Network, locationId, version string) 
(string, error) {
        url := fmt.Sprintf("/v1/catalog/locations/%s/%s", locationId, version)
        body, err := network.SendEmptyPostRequest(url)
-    if err != nil {
-        return "", err
-    }
+       if err != nil {
+               return "", err
+       }
        return string(body), nil
 }
 
 func Entities(network *net.Network) ([]models.CatalogItemSummary, error) {
        url := "/v1/catalog/entities"
-    var entities []models.CatalogItemSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return entities, err
-    }
+       var entities []models.CatalogItemSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return entities, err
+       }
        err = json.Unmarshal(body, &entities)
        return entities, err
 }
 
 func Catalog(network *net.Network) ([]models.CatalogItemSummary, error) {
        url := "/v1/catalog/applications"
-    var applications []models.CatalogItemSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return applications, err
-    }
+       var applications []models.CatalogItemSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return applications, err
+       }
        err = json.Unmarshal(body, &applications)
        return applications, err
 }
 
 func GetLocation(network *net.Network, locationId string) 
(models.CatalogLocationSummary, error) {
        url := fmt.Sprintf("/v1/catalog/locations/%s", locationId)
-    var catalogLocation models.CatalogLocationSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return catalogLocation, err
-    }
+       var catalogLocation models.CatalogLocationSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return catalogLocation, err
+       }
        err = json.Unmarshal(body, &catalogLocation)
        return catalogLocation, err
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/entities/entities.go
----------------------------------------------------------------------
diff --git a/api/entities/entities.go b/api/entities/entities.go
index 191bded..ca264c0 100644
--- a/api/entities/entities.go
+++ b/api/entities/entities.go
@@ -12,31 +12,31 @@ import (
 func GetTask(network *net.Network, application, entity, task string) (string, 
error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/activities/%s", 
application, entity, task)
        body, err := network.SendGetRequest(url)
-    // TODO return model
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       // TODO return model
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 //WIP
 func GetIcon(network *net.Network, application, entity string) (string, error) 
{
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/icon", application, 
entity)
        body, err := network.SendGetRequest(url)
-    // TODO return model
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       // TODO return model
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func Children(network *net.Network, application, entity string) 
([]models.EntitySummary, error) {
        urlStr := fmt.Sprintf("/v1/applications/%s/entities/%s/children", 
application, entity)
-    var entityList []models.EntitySummary
-    body, err := network.SendGetRequest(urlStr)
-    if err != nil {
-        return entityList, err
-    }
+       var entityList []models.EntitySummary
+       body, err := network.SendGetRequest(urlStr)
+       if err != nil {
+               return entityList, err
+       }
 
        err = json.Unmarshal(body, &entityList)
        return entityList, err
@@ -44,11 +44,11 @@ func Children(network *net.Network, application, entity 
string) ([]models.Entity
 
 func AddChildren(network *net.Network, application, entity, filePath string) 
(models.TaskSummary, error) {
        urlStr := fmt.Sprintf("/v1/applications/%s/entities/%s/children", 
application, entity)
-    var response models.TaskSummary
-    body, err := network.SendPostFileRequest(urlStr, filePath, 
"application/json")
-    if err != nil {
-        return response, err
-    }
+       var response models.TaskSummary
+       body, err := network.SendPostFileRequest(urlStr, filePath, 
"application/json")
+       if err != nil {
+               return response, err
+       }
 
        err = json.Unmarshal(body, &response)
        return response, err
@@ -58,51 +58,51 @@ func AddChildren(network *net.Network, application, entity, 
filePath string) (mo
 func GetLocations(network *net.Network, application, entity string) (string, 
error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/locations", 
application, entity)
        body, err := network.SendGetRequest(url)
-    // TODO return model
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       // TODO return model
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func Spec(network *net.Network, application, entity string) (string, error) {
        urlStr := fmt.Sprintf("/v1/applications/%s/entities/%s/spec", 
application, entity)
        body, err := network.SendGetRequest(urlStr)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 //WIP
 func GetDescendants(network *net.Network, application, entity string) (string, 
error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/descendants", 
application, entity)
        body, err := network.SendGetRequest(url)
-    // TODO return model
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       // TODO return model
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 //WIP
 func GetDescendantsSensor(network *net.Network, application, entity, sensor 
string) (string, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/descendants/sensor/%s", 
application, entity, sensor)
        body, err := network.SendGetRequest(url)
-    // TODO return model
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       // TODO return model
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func GetActivities(network *net.Network, application, entity string) 
([]models.TaskSummary, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/activities", 
application, entity)
-    var activityList []models.TaskSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return activityList, err
-    }
+       var activityList []models.TaskSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return activityList, err
+       }
 
        err = json.Unmarshal(body, &activityList)
        return activityList, err
@@ -112,44 +112,44 @@ func GetActivities(network *net.Network, application, 
entity string) ([]models.T
 func GetTags(network *net.Network, application, entity string) (string, error) 
{
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/tags", application, 
entity)
        body, err := network.SendGetRequest(url)
-    // TODO return model
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       // TODO return model
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 //WIP
 func Expunge(network *net.Network, application, entity string) (string, error) 
{
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/expunge", 
application, entity)
        body, err := network.SendEmptyPostRequest(url)
-    // TODO return model
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       // TODO return model
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 //WIP
 func GetEntity(network *net.Network, application, entity string) 
(models.EntitySummary, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s", application, 
entity)
-    summary := models.EntitySummary{}
-    body, err := network.SendGetRequest(url)
+       summary := models.EntitySummary{}
+       body, err := network.SendGetRequest(url)
        if err != nil {
                return summary, err
        }
 
-    err = json.Unmarshal(body, &summary)
-    return summary, err
+       err = json.Unmarshal(body, &summary)
+       return summary, err
 }
 
 func EntityList(network *net.Network, application string) 
([]models.EntitySummary, error) {
        urlStr := fmt.Sprintf("/v1/applications/%s/entities", application)
-    var entityList []models.EntitySummary
-    body, err := network.SendGetRequest(urlStr)
-    if err != nil {
-        return entityList, err
-    }
+       var entityList []models.EntitySummary
+       body, err := network.SendGetRequest(urlStr)
+       if err != nil {
+               return entityList, err
+       }
 
        err = json.Unmarshal(body, &entityList)
        return entityList, err
@@ -158,8 +158,8 @@ func EntityList(network *net.Network, application string) 
([]models.EntitySummar
 func Rename(network *net.Network, application, entity, newName string) 
(string, error) {
        urlStr := fmt.Sprintf("/v1/applications/%s/entities/%s/name?name=%s", 
application, entity, url.QueryEscape(newName))
        body, err := network.SendEmptyPostRequest(urlStr)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/entity_config/config.go
----------------------------------------------------------------------
diff --git a/api/entity_config/config.go b/api/entity_config/config.go
index cb3295b..c6c72cd 100644
--- a/api/entity_config/config.go
+++ b/api/entity_config/config.go
@@ -13,13 +13,13 @@ func ConfigValue(network *net.Network, application, entity, 
config string) (inte
                return nil, err
        }
 
-       var value interface{};
+       var value interface{}
        err = json.Unmarshal(bytes, &value)
        if nil != err {
                return nil, err
        }
 
-       return value, nil;
+       return value, nil
 }
 
 func ConfigValueAsBytes(network *net.Network, application, entity, config 
string) ([]byte, error) {
@@ -36,19 +36,19 @@ func SetConfig(network *net.Network, application, entity, 
config, value string)
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/config/%s", 
application, entity, config)
        val := []byte(value)
        body, err := network.SendPostRequest(url, val)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func ConfigList(network *net.Network, application, entity string) 
([]models.ConfigSummary, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/config", 
application, entity)
-    var configList []models.ConfigSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return configList, err
-    }
+       var configList []models.ConfigSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return configList, err
+       }
 
        err = json.Unmarshal(body, &configList)
        return configList, err
@@ -58,21 +58,19 @@ func PostConfig(network *net.Network, application, entity, 
config, value string)
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/config", 
application, entity)
        val := []byte(value)
        body, err := network.SendPostRequest(url, val)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
-
-
 func ConfigCurrentState(network *net.Network, application, entity string) 
(map[string]interface{}, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/config/current-state", 
application, entity)
-    var currentState map[string]interface{}
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return currentState, err
-    }
+       var currentState map[string]interface{}
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return currentState, err
+       }
        err = json.Unmarshal(body, &currentState)
        return currentState, err
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/entity_effectors/effectors.go
----------------------------------------------------------------------
diff --git a/api/entity_effectors/effectors.go 
b/api/entity_effectors/effectors.go
index 351e7e5..26dd85a 100644
--- a/api/entity_effectors/effectors.go
+++ b/api/entity_effectors/effectors.go
@@ -1,24 +1,24 @@
 package entity_effectors
 
 import (
+       "bytes"
        "encoding/json"
+       "errors"
        "fmt"
        "github.com/brooklyncentral/brooklyn-cli/models"
        "github.com/brooklyncentral/brooklyn-cli/net"
        "net/url"
-       "errors"
-       "strings"
-       "bytes"
        "strconv"
+       "strings"
 )
 
 func EffectorList(network *net.Network, application, entity string) 
([]models.EffectorSummary, error) {
        path := fmt.Sprintf("/v1/applications/%s/entities/%s/effectors", 
application, entity)
-    var effectorList []models.EffectorSummary
-    body, err := network.SendGetRequest(path)
-    if err != nil {
-        return effectorList, err
-    }
+       var effectorList []models.EffectorSummary
+       body, err := network.SendGetRequest(path)
+       if err != nil {
+               return effectorList, err
+       }
 
        err = json.Unmarshal(body, &effectorList)
        return effectorList, err
@@ -41,4 +41,4 @@ func TriggerEffector(network *net.Network, application, 
entity, effector string,
                return "", err
        }
        return string(body), nil
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/entity_policies/policies.go
----------------------------------------------------------------------
diff --git a/api/entity_policies/policies.go b/api/entity_policies/policies.go
index 6512e19..6626d7c 100644
--- a/api/entity_policies/policies.go
+++ b/api/entity_policies/policies.go
@@ -19,22 +19,22 @@ func AddPolicy(network *net.Network, application, entity, 
policy string, config
        req := network.NewPostRequest(path, 
bytes.NewBufferString(data.Encode()))
        req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
        req.Header.Add("Content-Length", strconv.Itoa(len(data.Encode())))
-    var policySummary models.PolicySummary
-    body, err := network.SendRequest(req)
-    if err != nil {
-        return policySummary, err
-    }
+       var policySummary models.PolicySummary
+       body, err := network.SendRequest(req)
+       if err != nil {
+               return policySummary, err
+       }
        err = json.Unmarshal(body, &policySummary)
        return policySummary, err
 }
 
 func PolicyList(network *net.Network, application, entity string) 
([]models.PolicySummary, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/policies", 
application, entity)
-    var policyList []models.PolicySummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return policyList, err
-    }
+       var policyList []models.PolicySummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return policyList, err
+       }
 
        err = json.Unmarshal(body, &policyList)
        return policyList, err
@@ -43,48 +43,44 @@ func PolicyList(network *net.Network, application, entity 
string) ([]models.Poli
 func PolicyStatus(network *net.Network, application, entity, policy string) 
(string, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s", 
application, entity, policy)
        body, err := network.SendGetRequest(url)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func CurrentState(network *net.Network, application, entity string) (string, 
error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/policies/current-state", 
application, entity)
        body, err := network.SendGetRequest(url)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func StartPolicy(network *net.Network, application, entity, policy string) 
(string, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s/start", 
application, entity, policy)
        body, err := network.SendEmptyPostRequest(url)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func StopPolicy(network *net.Network, application, entity, policy string) 
(string, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s/stop", 
application, entity, policy)
        body, err := network.SendEmptyPostRequest(url)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
 
 func DestroyPolicy(network *net.Network, application, entity, policy string) 
(string, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s/destroy", application, 
entity, policy)
        body, err := network.SendEmptyPostRequest(url)
-    if nil != err {
-        return "", err
-    }
-    return string(body), nil
+       if nil != err {
+               return "", err
+       }
+       return string(body), nil
 }
-
-
-
-

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/entity_policy_config/config.go
----------------------------------------------------------------------
diff --git a/api/entity_policy_config/config.go 
b/api/entity_policy_config/config.go
index 1814a8f..80d22b0 100644
--- a/api/entity_policy_config/config.go
+++ b/api/entity_policy_config/config.go
@@ -1,27 +1,27 @@
 package entity_policy_config
 
 import (
+       "encoding/json"
        "fmt"
        "github.com/brooklyncentral/brooklyn-cli/models"
        "github.com/brooklyncentral/brooklyn-cli/net"
-    "encoding/json"
 )
 
 func CurrentState(network *net.Network, application, entity, policy string) 
(string, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s/config/current-state", 
application, entity, policy)
        body, err := network.SendGetRequest(url)
-    if nil != err {
-        return "", err
-    }
+       if nil != err {
+               return "", err
+       }
        return string(body), nil
 }
 
 func GetConfigValue(network *net.Network, application, entity, policy, config 
string) (string, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s/config/%s", 
application, entity, policy, config)
        body, err := network.SendGetRequest(url)
-    if nil != err {
-        return "", err
-    }
+       if nil != err {
+               return "", err
+       }
        return string(body), nil
 }
 
@@ -29,19 +29,19 @@ func GetConfigValue(network *net.Network, application, 
entity, policy, config st
 func SetConfigValue(network *net.Network, application, entity, policy, config 
string) (string, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s/config/%s", 
application, entity, policy, config)
        body, err := network.SendEmptyPostRequest(url)
-    if nil != err {
-        return "", err
-    }
+       if nil != err {
+               return "", err
+       }
        return string(body), nil
 }
 
 func GetAllConfigValues(network *net.Network, application, entity, policy 
string) ([]models.PolicyConfigList, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/policies/%s/config", application, 
entity, policy)
-    var policyConfigList []models.PolicyConfigList
+       var policyConfigList []models.PolicyConfigList
        body, err := network.SendGetRequest(url)
-    if nil != err {
-        return policyConfigList, err
-    }
-    err = json.Unmarshal(body, &policyConfigList)
-    return policyConfigList, err
-}
\ No newline at end of file
+       if nil != err {
+               return policyConfigList, err
+       }
+       err = json.Unmarshal(body, &policyConfigList)
+       return policyConfigList, err
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/entity_sensors/sensors.go
----------------------------------------------------------------------
diff --git a/api/entity_sensors/sensors.go b/api/entity_sensors/sensors.go
index e3ba202..b67bb9a 100644
--- a/api/entity_sensors/sensors.go
+++ b/api/entity_sensors/sensors.go
@@ -7,31 +7,29 @@ import (
        "github.com/brooklyncentral/brooklyn-cli/net"
 )
 
-
-
 func SensorValue(network *net.Network, application, entity, sensor string) 
(interface{}, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/sensors/%s", 
application, entity, sensor)
        body, err := network.SendGetRequest(url)
-    if nil != err || 0 == len(body) {
-        return nil, err
-    }
+       if nil != err || 0 == len(body) {
+               return nil, err
+       }
 
-       var value interface{};
+       var value interface{}
        err = json.Unmarshal(body, &value)
        if nil != err {
                return nil, err
        }
 
-       return value, nil;
+       return value, nil
 }
 
 // WIP
 func DeleteSensor(network *net.Network, application, entity, sensor string) 
(string, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/sensors/%s", 
application, entity, sensor)
        body, err := network.SendDeleteRequest(url)
-    if nil != err {
-        return "", err
-    }
+       if nil != err {
+               return "", err
+       }
        return string(body), nil
 }
 
@@ -60,24 +58,23 @@ func DeleteSensor(network *net.Network, application, 
entity, sensor string) (str
 func SensorList(network *net.Network, application, entity string) 
([]models.SensorSummary, error) {
        url := fmt.Sprintf("/v1/applications/%s/entities/%s/sensors", 
application, entity)
        body, err := network.SendGetRequest(url)
-    var sensorList []models.SensorSummary
-    if err != nil {
-        return sensorList, err
-    }
+       var sensorList []models.SensorSummary
+       if err != nil {
+               return sensorList, err
+       }
 
        err = json.Unmarshal(body, &sensorList)
        return sensorList, err
 }
 
-
 func CurrentState(network *net.Network, application, entity string) 
(map[string]interface{}, error) {
        url := 
fmt.Sprintf("/v1/applications/%s/entities/%s/sensors/current-state", 
application, entity)
-    var currentState map[string]interface{}
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return currentState, err
-    }
+       var currentState map[string]interface{}
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return currentState, err
+       }
 
-    err = json.Unmarshal(body, &currentState)
+       err = json.Unmarshal(body, &currentState)
        return currentState, err
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/locations/locations.go
----------------------------------------------------------------------
diff --git a/api/locations/locations.go b/api/locations/locations.go
index 91a2471..af20d36 100644
--- a/api/locations/locations.go
+++ b/api/locations/locations.go
@@ -18,12 +18,12 @@ func LocatedLocations(network *net.Network) (string, error) 
{
 
 func GetLocation(network *net.Network, locationId string) 
(models.LocationSummary, error) {
        url := fmt.Sprintf("/v1/locations/%s", locationId)
-    var locationDetail models.LocationSummary
+       var locationDetail models.LocationSummary
        body, err := network.SendGetRequest(url)
        if err != nil {
                return locationDetail, err
        }
-    err = json.Unmarshal(body, &locationDetail)
+       err = json.Unmarshal(body, &locationDetail)
        return locationDetail, err
 }
 
@@ -48,11 +48,11 @@ func CreateLocation(network *net.Network, locationId 
string) (string, error) {
 
 func LocationList(network *net.Network) ([]models.LocationSummary, error) {
        url := "/v1/locations"
-    var locationList []models.LocationSummary
-    body, err := network.SendGetRequest(url)
-    if err != nil {
-        return locationList, err
-    }
+       var locationList []models.LocationSummary
+       body, err := network.SendGetRequest(url)
+       if err != nil {
+               return locationList, err
+       }
 
        err = json.Unmarshal(body, &locationList)
        return locationList, err

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/server/server.go
----------------------------------------------------------------------
diff --git a/api/server/server.go b/api/server/server.go
index b4d969c..5796386 100644
--- a/api/server/server.go
+++ b/api/server/server.go
@@ -34,7 +34,7 @@ func GetConfig(network *net.Network, configKey string) 
(string, error) {
        return string(body), nil
 }
 
-func Reload(network *net.Network)(string, error) {
+func Reload(network *net.Network) (string, error) {
        url := "/v1/server/properties/reload"
        body, err := network.SendEmptyPostRequest(url)
        if err != nil {
@@ -171,4 +171,4 @@ func Shutdown(network *net.Network) (string, error) {
                return "", err
        }
        return string(body)
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/usage/usage.go
----------------------------------------------------------------------
diff --git a/api/usage/usage.go b/api/usage/usage.go
index ab033f1..af3b85a 100644
--- a/api/usage/usage.go
+++ b/api/usage/usage.go
@@ -41,4 +41,4 @@ func Machines(network *net.Network) (string, error) {
                return "", err
        }
        return string(body), nil
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/api/version/version.go
----------------------------------------------------------------------
diff --git a/api/version/version.go b/api/version/version.go
index e08b6b1..eb06d6b 100644
--- a/api/version/version.go
+++ b/api/version/version.go
@@ -1,18 +1,18 @@
 package version
 
 import (
+       "encoding/json"
+       "github.com/brooklyncentral/brooklyn-cli/models"
        "github.com/brooklyncentral/brooklyn-cli/net"
-    "github.com/brooklyncentral/brooklyn-cli/models"
-    "encoding/json"
 )
 
 func Version(network *net.Network) (models.VersionSummary, error) {
        url := "/v1/server/version"
-    var versionSummary models.VersionSummary
+       var versionSummary models.VersionSummary
        body, err := network.SendGetRequest(url)
        if err != nil {
                return versionSummary, err
        }
-    err = json.Unmarshal(body, &versionSummary)
+       err = json.Unmarshal(body, &versionSummary)
        return versionSummary, err
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/app/app.go
----------------------------------------------------------------------
diff --git a/app/app.go b/app/app.go
index 70c5e30..f18c5ef 100644
--- a/app/app.go
+++ b/app/app.go
@@ -1,99 +1,98 @@
 package app
 
 import (
-    "fmt"
-    "github.com/codegangsta/cli"
-    "github.com/brooklyncentral/brooklyn-cli/command_metadata"
-    "github.com/brooklyncentral/brooklyn-cli/command_runner"
-    "strings"
-    "os"
-    "github.com/brooklyncentral/brooklyn-cli/error_handler"
+       "fmt"
+       "github.com/brooklyncentral/brooklyn-cli/command_metadata"
+       "github.com/brooklyncentral/brooklyn-cli/command_runner"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
+       "github.com/codegangsta/cli"
+       "os"
+       "strings"
 )
 
 type configDefaults struct {
-    Name     string
-    HelpName string
-    Usage    string
-    Version  string
+       Name     string
+       HelpName string
+       Usage    string
+       Version  string
 }
 
 var appConfig = configDefaults{
-    Name:         os.Args[0],
-    HelpName:     os.Args[0],
-    Usage:        "A Brooklyn command line client application",
-    Version:      "0.9.0",
+       Name:     os.Args[0],
+       HelpName: os.Args[0],
+       Usage:    "A Brooklyn command line client application",
+       Version:  "0.9.0",
 }
 
 func NewApp(baseName string, cmdRunner command_runner.Runner, metadatas 
...command_metadata.CommandMetadata) (app *cli.App) {
 
-    cli.AppHelpTemplate = appHelpTemplate()
-    cli.CommandHelpTemplate = commandHelpTemplate()
-    app = cli.NewApp()
-    app.Name = appConfig.Name
-    app.HelpName = appConfig.HelpName
-    app.Usage = appConfig.Usage
-    app.Version = appConfig.Version
-
-    app.Commands = []cli.Command{}
-
-    for _, metadata := range metadatas {
-        primaryCommand := getCommand(baseName, metadata, cmdRunner)
-        app.Commands = append(app.Commands, primaryCommand)
-    }
-    return
+       cli.AppHelpTemplate = appHelpTemplate()
+       cli.CommandHelpTemplate = commandHelpTemplate()
+       app = cli.NewApp()
+       app.Name = appConfig.Name
+       app.HelpName = appConfig.HelpName
+       app.Usage = appConfig.Usage
+       app.Version = appConfig.Version
+
+       app.Commands = []cli.Command{}
+
+       for _, metadata := range metadatas {
+               primaryCommand := getCommand(baseName, metadata, cmdRunner)
+               app.Commands = append(app.Commands, primaryCommand)
+       }
+       return
 }
 
 func getCommand(baseName string, metadata command_metadata.CommandMetadata, 
runner command_runner.Runner) cli.Command {
-    command := cli.Command{
-        Name:        metadata.Name,
-        Aliases:     metadata.Aliases,
-        ShortName:   metadata.ShortName,
-        Description: metadata.Description,
-        Usage:       strings.Replace(metadata.Usage, "BROOKLYN_NAME", 
baseName, -1),
-        Action: func(context *cli.Context) {
-            err := runner.RunCmdByName(metadata.Name, context)
-            if err != nil {
-                error_handler.ErrorExit(err)
-            }
-        },
-        Flags:           metadata.Flags,
-        SkipFlagParsing: metadata.SkipFlagParsing,
-    }
-
-    if nil != metadata.Operands {
-        command.Subcommands = make([]cli.Command, 0)
-        for _, operand := range metadata.Operands {
-            command.Subcommands = append(command.Subcommands, cli.Command{
-                Name:            operand.Name,
-                Aliases:         operand.Aliases,
-                ShortName:       operand.ShortName,
-                Description:     operand.Description,
-                Usage:           operand.Usage,
-                Flags:           operand.Flags,
-                SkipFlagParsing: operand.SkipFlagParsing,
-                Action:          subCommandAction(command.Name, operand.Name, 
runner),
-            })
-            command.Usage = strings.Join([]string{
-                command.Usage, "\n... ", operand.Usage, "\t", 
operand.Description,
-            }, "")
-        }
-    }
-
-    return command
+       command := cli.Command{
+               Name:        metadata.Name,
+               Aliases:     metadata.Aliases,
+               ShortName:   metadata.ShortName,
+               Description: metadata.Description,
+               Usage:       strings.Replace(metadata.Usage, "BROOKLYN_NAME", 
baseName, -1),
+               Action: func(context *cli.Context) {
+                       err := runner.RunCmdByName(metadata.Name, context)
+                       if err != nil {
+                               error_handler.ErrorExit(err)
+                       }
+               },
+               Flags:           metadata.Flags,
+               SkipFlagParsing: metadata.SkipFlagParsing,
+       }
+
+       if nil != metadata.Operands {
+               command.Subcommands = make([]cli.Command, 0)
+               for _, operand := range metadata.Operands {
+                       command.Subcommands = append(command.Subcommands, 
cli.Command{
+                               Name:            operand.Name,
+                               Aliases:         operand.Aliases,
+                               ShortName:       operand.ShortName,
+                               Description:     operand.Description,
+                               Usage:           operand.Usage,
+                               Flags:           operand.Flags,
+                               SkipFlagParsing: operand.SkipFlagParsing,
+                               Action:          subCommandAction(command.Name, 
operand.Name, runner),
+                       })
+                       command.Usage = strings.Join([]string{
+                               command.Usage, "\n... ", operand.Usage, "\t", 
operand.Description,
+                       }, "")
+               }
+       }
+
+       return command
 }
 
 func subCommandAction(command string, operand string, runner 
command_runner.Runner) func(context *cli.Context) {
-    return func(context *cli.Context) {
-        err := runner.RunSubCmdByName(command, operand, context)
-        if err != nil {
-            fmt.Fprintln(os.Stderr, err)
-        }
-    }
+       return func(context *cli.Context) {
+               err := runner.RunSubCmdByName(command, operand, context)
+               if err != nil {
+                       fmt.Fprintln(os.Stderr, err)
+               }
+       }
 }
 
-
 func appHelpTemplate() string {
-    return `NAME:
+       return `NAME:
    {{.Name}} - {{.Usage}}
 USAGE:
    {{.Name}} {{if .Flags}}[global options] {{end}}command{{if .Flags}} 
[command options]{{end}} [arguments...]
@@ -131,7 +130,7 @@ GLOBAL OPTIONS:
 }
 
 func commandHelpTemplate() string {
-    return `NAME:
+       return `NAME:
    {{.Name}} - {{.Description}}
 {{with .ShortName}}
 ALIAS:

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/br/brooklyn.go
----------------------------------------------------------------------
diff --git a/br/brooklyn.go b/br/brooklyn.go
index 68dc663..27eae05 100644
--- a/br/brooklyn.go
+++ b/br/brooklyn.go
@@ -4,15 +4,15 @@ import (
        "github.com/brooklyncentral/brooklyn-cli/app"
        "github.com/brooklyncentral/brooklyn-cli/command_factory"
        "github.com/brooklyncentral/brooklyn-cli/command_runner"
-       "github.com/brooklyncentral/brooklyn-cli/net"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
        "github.com/brooklyncentral/brooklyn-cli/io"
+       "github.com/brooklyncentral/brooklyn-cli/net"
+       "github.com/brooklyncentral/brooklyn-cli/scope"
        "os"
        "path/filepath"
-       "github.com/brooklyncentral/brooklyn-cli/scope"
-       "github.com/brooklyncentral/brooklyn-cli/error_handler"
 )
 
-func getNetworkCredentialsFromConfig(yamlMap map[string]interface{}) (string, 
string, string){
+func getNetworkCredentialsFromConfig(yamlMap map[string]interface{}) (string, 
string, string) {
        var target, username, password string
        target, found := yamlMap["target"].(string)
        if found {
@@ -30,7 +30,7 @@ func getNetworkCredentialsFromConfig(yamlMap 
map[string]interface{}) (string, st
 
 func main() {
        config := io.GetConfig()
-       target, username, password := 
getNetworkCredentialsFromConfig(config.Map) 
+       target, username, password := 
getNetworkCredentialsFromConfig(config.Map)
        //target, username, password := "http://192.168.50.101:8081";, 
"brooklyn", "Sns4Hh9j7l"
        network := net.NewNetwork(target, username, password)
        cmdFactory := command_factory.NewFactory(network, config)

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/command/command.go
----------------------------------------------------------------------
diff --git a/command/command.go b/command/command.go
index 0eb2ff5..799085f 100644
--- a/command/command.go
+++ b/command/command.go
@@ -1,9 +1,9 @@
 package command
 
 import (
-       "github.com/codegangsta/cli"
        "github.com/brooklyncentral/brooklyn-cli/command_metadata"
        "github.com/brooklyncentral/brooklyn-cli/scope"
+       "github.com/codegangsta/cli"
 )
 
 type Command interface {

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/command/supercommand.go
----------------------------------------------------------------------
diff --git a/command/supercommand.go b/command/supercommand.go
index d8ad024..54008b8 100644
--- a/command/supercommand.go
+++ b/command/supercommand.go
@@ -2,12 +2,11 @@ package command
 
 // A command with further (sub) commands, like 'git remote', with its 'git 
remote add' etc.
 type SuperCommand interface {
-
        Command
 
        // Get the sub command wih the given name
        SubCommand(name string) Command
 
        // Get the names of all subcommands
-       SubCommandNames() ([]string)
+       SubCommandNames() []string
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/command_factory/factory.go
----------------------------------------------------------------------
diff --git a/command_factory/factory.go b/command_factory/factory.go
index 517625b..d1db35c 100644
--- a/command_factory/factory.go
+++ b/command_factory/factory.go
@@ -2,12 +2,12 @@ package command_factory
 
 import (
        "errors"
-       "sort"
        "github.com/brooklyncentral/brooklyn-cli/command"
        "github.com/brooklyncentral/brooklyn-cli/command_metadata"
        "github.com/brooklyncentral/brooklyn-cli/commands"
-       "github.com/brooklyncentral/brooklyn-cli/net"
        "github.com/brooklyncentral/brooklyn-cli/io"
+       "github.com/brooklyncentral/brooklyn-cli/net"
+       "sort"
        "strings"
 )
 
@@ -18,11 +18,10 @@ type Factory interface {
 }
 
 type concreteFactory struct {
-       cmdsByName map[string]command.Command
+       cmdsByName  map[string]command.Command
        subCommands map[string]map[string]command.Command
 }
 
-
 func NewFactory(network *net.Network, config *io.Config) (factory 
concreteFactory) {
        factory.cmdsByName = make(map[string]command.Command)
        factory.subCommands = make(map[string]map[string]command.Command)
@@ -39,18 +38,18 @@ func NewFactory(network *net.Network, config *io.Config) 
(factory concreteFactor
        factory.simpleCommand(commands.NewApplication(network))
        //factory.simpleCommand(commands.NewApplications(network))
        factory.simpleCommand(commands.NewCatalog(network))
-    factory.simpleCommand(commands.NewConfig(network))
-    factory.simpleCommand(commands.NewDeploy(network))
-    factory.simpleCommand(commands.NewDelete(network))
-    factory.simpleCommand(commands.NewDestroyPolicy(network))
-    factory.simpleCommand(commands.NewEffector(network))
-    factory.simpleCommand(commands.NewEntity(network))
+       factory.simpleCommand(commands.NewConfig(network))
+       factory.simpleCommand(commands.NewDeploy(network))
+       factory.simpleCommand(commands.NewDelete(network))
+       factory.simpleCommand(commands.NewDestroyPolicy(network))
+       factory.simpleCommand(commands.NewEffector(network))
+       factory.simpleCommand(commands.NewEntity(network))
        factory.simpleCommand(commands.NewInvoke(network))
-    factory.simpleCommand(commands.NewInvokeRestart(network))
-    factory.simpleCommand(commands.NewInvokeStart(network))
-    factory.simpleCommand(commands.NewInvokeStop(network))
-    // NewList below is not used but we retain the code as an example of how 
to do a super command.
-    // factory.superCommand(commands.NewList(network))
+       factory.simpleCommand(commands.NewInvokeRestart(network))
+       factory.simpleCommand(commands.NewInvokeStart(network))
+       factory.simpleCommand(commands.NewInvokeStop(network))
+       // NewList below is not used but we retain the code as an example of 
how to do a super command.
+       //      factory.superCommand(commands.NewList(network))
        factory.simpleCommand(commands.NewLocations(network))
        factory.simpleCommand(commands.NewLogin(network, config))
        factory.simpleCommand(commands.NewPolicy(network))
@@ -66,14 +65,13 @@ func NewFactory(network *net.Network, config *io.Config) 
(factory concreteFactor
        return factory
 }
 
-
 func (factory *concreteFactory) simpleCommand(cmd command.Command) {
        factory.cmdsByName[cmd.Metadata().Name] = cmd
 }
 
-func (factory *concreteFactory) superCommand(cmd command.SuperCommand)  {
+func (factory *concreteFactory) superCommand(cmd command.SuperCommand) {
 
-    factory.simpleCommand(cmd)
+       factory.simpleCommand(cmd)
 
        if nil == factory.subCommands[cmd.Metadata().Name] {
                factory.subCommands[cmd.Metadata().Name] = 
make(map[string]command.Command)
@@ -112,11 +110,11 @@ func (f concreteFactory) GetBySubCmdName(cmdName string, 
subCmdName string) (cmd
 
 func (factory concreteFactory) CommandMetadatas() (commands 
[]command_metadata.CommandMetadata) {
        keys := make([]string, 0, len(factory.cmdsByName))
-    for key := range factory.cmdsByName {
-        keys = append(keys, key)
-    }
-    sort.Strings(keys)
-       
+       for key := range factory.cmdsByName {
+               keys = append(keys, key)
+       }
+       sort.Strings(keys)
+
        for _, key := range keys {
                command := factory.cmdsByName[key]
                commands = append(commands, command.Metadata())

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/command_runner/runner.go
----------------------------------------------------------------------
diff --git a/command_runner/runner.go b/command_runner/runner.go
index 4582915..5c4919b 100644
--- a/command_runner/runner.go
+++ b/command_runner/runner.go
@@ -1,9 +1,9 @@
 package command_runner
 
 import (
-       "github.com/codegangsta/cli"
        "github.com/brooklyncentral/brooklyn-cli/command_factory"
        "github.com/brooklyncentral/brooklyn-cli/scope"
+       "github.com/codegangsta/cli"
 )
 
 type Runner interface {
@@ -13,7 +13,7 @@ type Runner interface {
 
 type ConcreteRunner struct {
        cmdFactory command_factory.Factory
-       scope scope.Scope
+       scope      scope.Scope
 }
 
 func NewRunner(scope scope.Scope, cmdFactory command_factory.Factory) (runner 
ConcreteRunner) {

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/access.go
----------------------------------------------------------------------
diff --git a/commands/access.go b/commands/access.go
index 100eb69..3d61e67 100644
--- a/commands/access.go
+++ b/commands/access.go
@@ -2,12 +2,12 @@ package commands
 
 import (
        "fmt"
-       "github.com/codegangsta/cli"
        "github.com/brooklyncentral/brooklyn-cli/api/access_control"
        "github.com/brooklyncentral/brooklyn-cli/command_metadata"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
        "github.com/brooklyncentral/brooklyn-cli/net"
        "github.com/brooklyncentral/brooklyn-cli/scope"
-    "github.com/brooklyncentral/brooklyn-cli/error_handler"
+       "github.com/codegangsta/cli"
 )
 
 type Access struct {
@@ -30,12 +30,12 @@ func (cmd *Access) Metadata() 
command_metadata.CommandMetadata {
 }
 
 func (cmd *Access) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
        access, err := access_control.Access(cmd.network)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
        fmt.Println("Location Provisioning Allowed:", 
access.LocationProvisioningAllowed)
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/activity-stream.go
----------------------------------------------------------------------
diff --git a/commands/activity-stream.go b/commands/activity-stream.go
index 1f16aaa..4cb5814 100644
--- a/commands/activity-stream.go
+++ b/commands/activity-stream.go
@@ -1,131 +1,131 @@
 package commands
 
 import (
-    "fmt"
-    "github.com/codegangsta/cli"
-    "github.com/brooklyncentral/brooklyn-cli/api/activities"
-    "github.com/brooklyncentral/brooklyn-cli/command_metadata"
-    "github.com/brooklyncentral/brooklyn-cli/net"
-    "github.com/brooklyncentral/brooklyn-cli/scope"
-    "github.com/brooklyncentral/brooklyn-cli/error_handler"
+       "fmt"
+       "github.com/brooklyncentral/brooklyn-cli/api/activities"
+       "github.com/brooklyncentral/brooklyn-cli/command_metadata"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
+       "github.com/brooklyncentral/brooklyn-cli/net"
+       "github.com/brooklyncentral/brooklyn-cli/scope"
+       "github.com/codegangsta/cli"
 )
 
 type ActivityStreamEnv struct {
-    network *net.Network
+       network *net.Network
 }
 
 type ActivityStreamStderr struct {
-    network *net.Network
+       network *net.Network
 }
 
 type ActivityStreamStdin struct {
-    network *net.Network
+       network *net.Network
 }
 
 type ActivityStreamStdout struct {
-    network *net.Network
+       network *net.Network
 }
 
 func NewActivityStreamEnv(network *net.Network) (cmd *ActivityStreamEnv) {
-    cmd = new(ActivityStreamEnv)
-    cmd.network = network
-    return
+       cmd = new(ActivityStreamEnv)
+       cmd.network = network
+       return
 }
 
 func NewActivityStreamStderr(network *net.Network) (cmd *ActivityStreamStderr) 
{
-    cmd = new(ActivityStreamStderr)
-    cmd.network = network
-    return
+       cmd = new(ActivityStreamStderr)
+       cmd.network = network
+       return
 }
 
 func NewActivityStreamStdin(network *net.Network) (cmd *ActivityStreamStdin) {
-    cmd = new(ActivityStreamStdin)
-    cmd.network = network
-    return
+       cmd = new(ActivityStreamStdin)
+       cmd.network = network
+       return
 }
 
 func NewActivityStreamStdout(network *net.Network) (cmd *ActivityStreamStdout) 
{
-    cmd = new(ActivityStreamStdout)
-    cmd.network = network
-    return
+       cmd = new(ActivityStreamStdout)
+       cmd.network = network
+       return
 }
 
 func (cmd *ActivityStreamEnv) Metadata() command_metadata.CommandMetadata {
-    return command_metadata.CommandMetadata{
-        Name:        "env",
-        Description: "Show the ENV stream for a given activity",
-        Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE env",
-        Flags:       []cli.Flag{},
-    }
+       return command_metadata.CommandMetadata{
+               Name:        "env",
+               Description: "Show the ENV stream for a given activity",
+               Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE env",
+               Flags:       []cli.Flag{},
+       }
 }
 
 func (cmd *ActivityStreamStderr) Metadata() command_metadata.CommandMetadata {
-    return command_metadata.CommandMetadata{
-        Name:        "stderr",
-        Description: "Show the STDERR stream for a given activity",
-        Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE stderr",
-        Flags:       []cli.Flag{},
-    }
+       return command_metadata.CommandMetadata{
+               Name:        "stderr",
+               Description: "Show the STDERR stream for a given activity",
+               Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE stderr",
+               Flags:       []cli.Flag{},
+       }
 }
 
 func (cmd *ActivityStreamStdin) Metadata() command_metadata.CommandMetadata {
-    return command_metadata.CommandMetadata{
-        Name:        "stdin",
-        Description: "Show the STDIN stream for a given activity",
-        Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE ] stdin",
-        Flags:       []cli.Flag{},
-    }
+       return command_metadata.CommandMetadata{
+               Name:        "stdin",
+               Description: "Show the STDIN stream for a given activity",
+               Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE ] stdin",
+               Flags:       []cli.Flag{},
+       }
 }
 
 func (cmd *ActivityStreamStdout) Metadata() command_metadata.CommandMetadata {
-    return command_metadata.CommandMetadata{
-        Name:        "stdout",
-        Description: "Show the STDOUT stream for a given activity",
-        Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE stdout",
-        Flags:       []cli.Flag{},
-    }
+       return command_metadata.CommandMetadata{
+               Name:        "stdout",
+               Description: "Show the STDOUT stream for a given activity",
+               Usage:       "BROOKLYN_NAME ACTIVITY-SCOPE stdout",
+               Flags:       []cli.Flag{},
+       }
 }
 
 func (cmd *ActivityStreamEnv) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
-    activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "env")
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    fmt.Println(activityStream)
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
+       activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "env")
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       fmt.Println(activityStream)
 }
 
 func (cmd *ActivityStreamStderr) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
-    activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "stderr")
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    fmt.Println(activityStream)
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
+       activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "stderr")
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       fmt.Println(activityStream)
 }
 
 func (cmd *ActivityStreamStdin) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
-    activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "stdin")
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    fmt.Println(activityStream)
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
+       activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "stdin")
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       fmt.Println(activityStream)
 }
 
 func (cmd *ActivityStreamStdout) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
-    activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "stdout")
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    fmt.Println(activityStream)
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
+       activityStream, err := activities.ActivityStream(cmd.network, 
scope.Activity, "stdout")
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       fmt.Println(activityStream)
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/activity.go
----------------------------------------------------------------------
diff --git a/commands/activity.go b/commands/activity.go
index 4a6eec9..684b61c 100644
--- a/commands/activity.go
+++ b/commands/activity.go
@@ -1,145 +1,144 @@
 package commands
 
 import (
-    "github.com/codegangsta/cli"
-    "github.com/brooklyncentral/brooklyn-cli/api/activities"
-    "github.com/brooklyncentral/brooklyn-cli/command_metadata"
-    "github.com/brooklyncentral/brooklyn-cli/net"
-    "github.com/brooklyncentral/brooklyn-cli/terminal"
-    "strconv"
-    "time"
-    "github.com/brooklyncentral/brooklyn-cli/scope"
-    "github.com/brooklyncentral/brooklyn-cli/api/entities"
-    "fmt"
-    "github.com/brooklyncentral/brooklyn-cli/error_handler"
-"github.com/brooklyncentral/brooklyn-cli/models"
-    "strings"
-    "sort"
+       "fmt"
+       "github.com/brooklyncentral/brooklyn-cli/api/activities"
+       "github.com/brooklyncentral/brooklyn-cli/api/entities"
+       "github.com/brooklyncentral/brooklyn-cli/command_metadata"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
+       "github.com/brooklyncentral/brooklyn-cli/models"
+       "github.com/brooklyncentral/brooklyn-cli/net"
+       "github.com/brooklyncentral/brooklyn-cli/scope"
+       "github.com/brooklyncentral/brooklyn-cli/terminal"
+       "github.com/codegangsta/cli"
+       "sort"
+       "strconv"
+       "strings"
+       "time"
 )
 
 type Activity struct {
-    network *net.Network
+       network *net.Network
 }
 
 func NewActivity(network *net.Network) (cmd *Activity) {
-    cmd = new(Activity)
-    cmd.network = network
-    return
+       cmd = new(Activity)
+       cmd.network = network
+       return
 }
 
 func (cmd *Activity) Metadata() command_metadata.CommandMetadata {
-    return command_metadata.CommandMetadata{
-        Name:        "activity",
-        Aliases:     []string{"activities", "act", "acts"},
-        Description: "Show the activity for an application / entity",
-        Usage:       "BROOKLYN_NAME SCOPE activity [ ACTIVITYID]",
-        Flags:       []cli.Flag{
-            cli.StringSliceFlag{
-                Name: "children, c",
-                Usage: "List children of the activity",
-            },
-        },
-    }
+       return command_metadata.CommandMetadata{
+               Name:        "activity",
+               Aliases:     []string{"activities", "act", "acts"},
+               Description: "Show the activity for an application / entity",
+               Usage:       "BROOKLYN_NAME SCOPE activity [ ACTIVITYID]",
+               Flags: []cli.Flag{
+                       cli.StringSliceFlag{
+                               Name:  "children, c",
+                               Usage: "List children of the activity",
+                       },
+               },
+       }
 }
 
 func (cmd *Activity) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
-    if c.NumFlags() > 0 && c.FlagNames()[0] == "children" {
-        cmd.listchildren(c.StringSlice("children")[0])
-    } else {
-        if c.Args().Present() {
-            cmd.show(c.Args().First())
-        } else {
-            if scope.Activity == "" {
-                cmd.list(scope.Application, scope.Entity)
-            } else {
-                cmd.listchildren(scope.Activity)
-            }
-        }
-    }
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
+       if c.NumFlags() > 0 && c.FlagNames()[0] == "children" {
+               cmd.listchildren(c.StringSlice("children")[0])
+       } else {
+               if c.Args().Present() {
+                       cmd.show(c.Args().First())
+               } else {
+                       if scope.Activity == "" {
+                               cmd.list(scope.Application, scope.Entity)
+                       } else {
+                               cmd.listchildren(scope.Activity)
+                       }
+               }
+       }
 }
 
 func (cmd *Activity) show(activityId string) {
-    activity, err := activities.Activity(cmd.network, activityId)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
+       activity, err := activities.Activity(cmd.network, activityId)
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
 
-    table := terminal.NewTable([]string{"Id:", activity.Id})
-    table.Add("DisplayName:", activity.DisplayName)
-    table.Add("Description:", activity.Description)
-    table.Add("EntityId:", activity.EntityId)
-    table.Add("EntityDisplayName:", activity.EntityDisplayName)
-    table.Add("Submitted:", time.Unix(activity.SubmitTimeUtc / 1000, 
0).Format(time.UnixDate))
-    table.Add("Started:", time.Unix(activity.StartTimeUtc / 1000, 
0).Format(time.UnixDate))
-    table.Add("Ended:", time.Unix(activity.EndTimeUtc / 1000, 
0).Format(time.UnixDate))
-    table.Add("CurrentStatus:", activity.CurrentStatus)
-    table.Add("IsError:", strconv.FormatBool(activity.IsError))
-    table.Add("IsCancelled:", strconv.FormatBool(activity.IsCancelled))
-    table.Add("SubmittedByTask:", activity.SubmittedByTask.Metadata.Id)
-    if activity.Streams["stdin"].Metadata.Size > 0 ||
-    activity.Streams["stdout"].Metadata.Size > 0 ||
-    activity.Streams["stderr"].Metadata.Size > 0 ||
-    activity.Streams["env"].Metadata.Size > 0 {
-        table.Add("Streams:", fmt.Sprintf("stdin: %d, stdout: %d, stderr: %d, 
env %d",
-            activity.Streams["stdin"].Metadata.Size,
-            activity.Streams["stdout"].Metadata.Size,
-            activity.Streams["stderr"].Metadata.Size,
-            activity.Streams["env"].Metadata.Size))
-    } else {
-        table.Add("Streams:", "")
-    }
-    table.Add("DetailedStatus:", fmt.Sprintf("\"%s\"", 
activity.DetailedStatus))
-    table.Print()
+       table := terminal.NewTable([]string{"Id:", activity.Id})
+       table.Add("DisplayName:", activity.DisplayName)
+       table.Add("Description:", activity.Description)
+       table.Add("EntityId:", activity.EntityId)
+       table.Add("EntityDisplayName:", activity.EntityDisplayName)
+       table.Add("Submitted:", time.Unix(activity.SubmitTimeUtc/1000, 
0).Format(time.UnixDate))
+       table.Add("Started:", time.Unix(activity.StartTimeUtc/1000, 
0).Format(time.UnixDate))
+       table.Add("Ended:", time.Unix(activity.EndTimeUtc/1000, 
0).Format(time.UnixDate))
+       table.Add("CurrentStatus:", activity.CurrentStatus)
+       table.Add("IsError:", strconv.FormatBool(activity.IsError))
+       table.Add("IsCancelled:", strconv.FormatBool(activity.IsCancelled))
+       table.Add("SubmittedByTask:", activity.SubmittedByTask.Metadata.Id)
+       if activity.Streams["stdin"].Metadata.Size > 0 ||
+               activity.Streams["stdout"].Metadata.Size > 0 ||
+               activity.Streams["stderr"].Metadata.Size > 0 ||
+               activity.Streams["env"].Metadata.Size > 0 {
+               table.Add("Streams:", fmt.Sprintf("stdin: %d, stdout: %d, 
stderr: %d, env %d",
+                       activity.Streams["stdin"].Metadata.Size,
+                       activity.Streams["stdout"].Metadata.Size,
+                       activity.Streams["stderr"].Metadata.Size,
+                       activity.Streams["env"].Metadata.Size))
+       } else {
+               table.Add("Streams:", "")
+       }
+       table.Add("DetailedStatus:", fmt.Sprintf("\"%s\"", 
activity.DetailedStatus))
+       table.Print()
 }
 
 func (cmd *Activity) list(application, entity string) {
-    activityList, err := entities.GetActivities(cmd.network, application, 
entity)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    table := terminal.NewTable([]string{"Id", "Task", "Submitted", "Status", 
"Streams"})
-    for _, activity := range activityList {
-        table.Add(activity.Id,
-            truncate(activity.DisplayName),
-            time.Unix(activity.SubmitTimeUtc / 1000, 0).Format(time.UnixDate), 
truncate(activity.CurrentStatus),
-            streams(activity))
-    }
-    table.Print()
+       activityList, err := entities.GetActivities(cmd.network, application, 
entity)
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       table := terminal.NewTable([]string{"Id", "Task", "Submitted", 
"Status", "Streams"})
+       for _, activity := range activityList {
+               table.Add(activity.Id,
+                       truncate(activity.DisplayName),
+                       time.Unix(activity.SubmitTimeUtc/1000, 
0).Format(time.UnixDate), truncate(activity.CurrentStatus),
+                       streams(activity))
+       }
+       table.Print()
 }
 
 func (cmd *Activity) listchildren(activity string) {
-    activityList, err := activities.ActivityChildren(cmd.network, activity)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    table := terminal.NewTable([]string{"Id", "Task", "Submitted", "Status", 
"Streams"})
-    for _, activity := range activityList {
-        table.Add(activity.Id,
-            truncate(activity.DisplayName),
-            time.Unix(activity.SubmitTimeUtc / 1000, 0).Format(time.UnixDate), 
truncate(activity.CurrentStatus),
-            streams(activity))
-    }
-    table.Print()
+       activityList, err := activities.ActivityChildren(cmd.network, activity)
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       table := terminal.NewTable([]string{"Id", "Task", "Submitted", 
"Status", "Streams"})
+       for _, activity := range activityList {
+               table.Add(activity.Id,
+                       truncate(activity.DisplayName),
+                       time.Unix(activity.SubmitTimeUtc/1000, 
0).Format(time.UnixDate), truncate(activity.CurrentStatus),
+                       streams(activity))
+       }
+       table.Print()
 }
 
 func streams(act models.TaskSummary) string {
-    names := make([]string, 0)
-    for name, _ := range act.Streams {
-        names = append(names, name)
-    }
-    sort.Strings(names)
-    return strings.Join(names, ",")
+       names := make([]string, 0)
+       for name, _ := range act.Streams {
+               names = append(names, name)
+       }
+       sort.Strings(names)
+       return strings.Join(names, ",")
 }
 
-
 const truncLimit = 40
 
 func truncate(text string) string {
-    if len(text) < truncLimit {
-        return text
-    }
-    return text[0:(truncLimit - 3)] + "..."
-}
\ No newline at end of file
+       if len(text) < truncLimit {
+               return text
+       }
+       return text[0:(truncLimit-3)] + "..."
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/add-catalog.go
----------------------------------------------------------------------
diff --git a/commands/add-catalog.go b/commands/add-catalog.go
index e2a4980..1fb6fda 100644
--- a/commands/add-catalog.go
+++ b/commands/add-catalog.go
@@ -2,12 +2,12 @@ package commands
 
 import (
        "fmt"
-       "github.com/codegangsta/cli"
        "github.com/brooklyncentral/brooklyn-cli/api/catalog"
        "github.com/brooklyncentral/brooklyn-cli/command_metadata"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
        "github.com/brooklyncentral/brooklyn-cli/net"
        "github.com/brooklyncentral/brooklyn-cli/scope"
-    "github.com/brooklyncentral/brooklyn-cli/error_handler"
+       "github.com/codegangsta/cli"
 )
 
 type AddCatalog struct {
@@ -30,12 +30,12 @@ func (cmd *AddCatalog) Metadata() 
command_metadata.CommandMetadata {
 }
 
 func (cmd *AddCatalog) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
        create, err := catalog.AddCatalog(cmd.network, c.Args().First())
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
        fmt.Println(create)
 }

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/add-children.go
----------------------------------------------------------------------
diff --git a/commands/add-children.go b/commands/add-children.go
index 53cb66d..8b691e1 100644
--- a/commands/add-children.go
+++ b/commands/add-children.go
@@ -1,14 +1,14 @@
 package commands
 
 import (
-       "github.com/codegangsta/cli"
        "github.com/brooklyncentral/brooklyn-cli/api/entities"
        "github.com/brooklyncentral/brooklyn-cli/command_metadata"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
        "github.com/brooklyncentral/brooklyn-cli/net"
+       "github.com/brooklyncentral/brooklyn-cli/scope"
        "github.com/brooklyncentral/brooklyn-cli/terminal"
+       "github.com/codegangsta/cli"
        "time"
-       "github.com/brooklyncentral/brooklyn-cli/scope"
-    "github.com/brooklyncentral/brooklyn-cli/error_handler"
 )
 
 type AddChildren struct {
@@ -31,13 +31,13 @@ func (cmd *AddChildren) Metadata() 
command_metadata.CommandMetadata {
 }
 
 func (cmd *AddChildren) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
        activity, err := entities.AddChildren(cmd.network, scope.Application, 
scope.Entity, c.Args().First())
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
        table := terminal.NewTable([]string{"Id", "Task", "Submitted", 
"Status"})
        table.Add(activity.Id, activity.DisplayName, 
time.Unix(activity.SubmitTimeUtc/1000, 0).Format(time.UnixDate), 
activity.CurrentStatus)
 

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/add-location.go
----------------------------------------------------------------------
diff --git a/commands/add-location.go b/commands/add-location.go
index c3f8928..8d9d2a9 100644
--- a/commands/add-location.go
+++ b/commands/add-location.go
@@ -12,4 +12,4 @@ func NewAddLocation(network *net.Network) (cmd *AddLocation) {
        cmd = new(AddLocation)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/application.go
----------------------------------------------------------------------
diff --git a/commands/application.go b/commands/application.go
index d4fcb6c..8603ed0 100644
--- a/commands/application.go
+++ b/commands/application.go
@@ -1,18 +1,18 @@
 package commands
 
 import (
-    "github.com/codegangsta/cli"
+       "fmt"
        "github.com/brooklyncentral/brooklyn-cli/api/application"
+       "github.com/brooklyncentral/brooklyn-cli/api/entities"
+       "github.com/brooklyncentral/brooklyn-cli/api/entity_sensors"
+       "github.com/brooklyncentral/brooklyn-cli/api/locations"
        "github.com/brooklyncentral/brooklyn-cli/command_metadata"
+       "github.com/brooklyncentral/brooklyn-cli/error_handler"
        "github.com/brooklyncentral/brooklyn-cli/net"
+       "github.com/brooklyncentral/brooklyn-cli/scope"
        "github.com/brooklyncentral/brooklyn-cli/terminal"
+       "github.com/codegangsta/cli"
        "strings"
-       "github.com/brooklyncentral/brooklyn-cli/scope"
-    "github.com/brooklyncentral/brooklyn-cli/error_handler"
-    "github.com/brooklyncentral/brooklyn-cli/api/entities"
-    "fmt"
-    "github.com/brooklyncentral/brooklyn-cli/api/entity_sensors"
-    "github.com/brooklyncentral/brooklyn-cli/api/locations"
 )
 
 type Application struct {
@@ -28,7 +28,7 @@ func NewApplication(network *net.Network) (cmd *Application) {
 func (cmd *Application) Metadata() command_metadata.CommandMetadata {
        return command_metadata.CommandMetadata{
                Name:        "application",
-               Aliases:     []string{"applications","app","apps"},
+               Aliases:     []string{"applications", "app", "apps"},
                Description: "Show the status and location of running 
applications",
                Usage:       "BROOKLYN_NAME application [APP]",
                Flags:       []cli.Flag{},
@@ -36,57 +36,58 @@ func (cmd *Application) Metadata() 
command_metadata.CommandMetadata {
 }
 
 func (cmd *Application) Run(scope scope.Scope, c *cli.Context) {
-    if err := net.VerifyLoginURL(cmd.network); err != nil {
-        error_handler.ErrorExit(err)
-    }
+       if err := net.VerifyLoginURL(cmd.network); err != nil {
+               error_handler.ErrorExit(err)
+       }
        if c.Args().Present() {
                cmd.show(c.Args().First())
        } else {
                cmd.list()
-       }       
+       }
 }
 
 const serviceIsUpStr = "service.isUp"
+
 func (cmd *Application) show(appName string) {
        application, err := application.Application(cmd.network, appName)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    entity, err := entities.GetEntity(cmd.network, appName, appName)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    state, err := entity_sensors.CurrentState(cmd.network, appName, appName)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
-    location, err := locations.GetLocation(cmd.network, 
application.Spec.Locations[0])
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       entity, err := entities.GetEntity(cmd.network, appName, appName)
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       state, err := entity_sensors.CurrentState(cmd.network, appName, appName)
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
+       location, err := locations.GetLocation(cmd.network, 
application.Spec.Locations[0])
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
        table := terminal.NewTable([]string{"Id:", application.Id})
        table.Add("Name:", application.Spec.Name)
        table.Add("Status:", string(application.Status))
-    if serviceUp, ok := state[serviceIsUpStr]; ok {
-        table.Add("ServiceUp:", fmt.Sprintf("%v", serviceUp))
-    }
+       if serviceUp, ok := state[serviceIsUpStr]; ok {
+               table.Add("ServiceUp:", fmt.Sprintf("%v", serviceUp))
+       }
        table.Add("Type:", application.Spec.Type)
-    table.Add("CatalogItemId:", entity.CatalogItemId)
-    table.Add("LocationId:", strings.Join(application.Spec.Locations, ", "))
+       table.Add("CatalogItemId:", entity.CatalogItemId)
+       table.Add("LocationId:", strings.Join(application.Spec.Locations, ", "))
        table.Add("LocationName:", location.Name)
        table.Add("LocationSpec:", location.Spec)
-    table.Add("LocationType:", location.Type)
+       table.Add("LocationType:", location.Type)
        table.Print()
 }
 
 func (cmd *Application) list() {
        applications, err := application.Applications(cmd.network)
-    if nil != err {
-        error_handler.ErrorExit(err)
-    }
+       if nil != err {
+               error_handler.ErrorExit(err)
+       }
        table := terminal.NewTable([]string{"Id", "Name", "Status", "Location"})
        for _, app := range applications {
                table.Add(app.Id, app.Spec.Name, string(app.Status), 
strings.Join(app.Spec.Locations, ", "))
        }
        table.Print()
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/catalog-applications.go
----------------------------------------------------------------------
diff --git a/commands/catalog-applications.go b/commands/catalog-applications.go
index d96ffe0..c25657e 100644
--- a/commands/catalog-applications.go
+++ b/commands/catalog-applications.go
@@ -12,4 +12,4 @@ func NewCatalogApplication(network *net.Network) (cmd 
*CatalogApplication) {
        cmd = new(CatalogApplication)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/catalog-entities.go
----------------------------------------------------------------------
diff --git a/commands/catalog-entities.go b/commands/catalog-entities.go
index 7a7b371..2341b7e 100644
--- a/commands/catalog-entities.go
+++ b/commands/catalog-entities.go
@@ -12,4 +12,4 @@ func NewCatalogEntities(network *net.Network) (cmd 
*CatalogEntities) {
        cmd = new(CatalogEntities)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/catalog-entity.go
----------------------------------------------------------------------
diff --git a/commands/catalog-entity.go b/commands/catalog-entity.go
index 8e2fb13..19d2c37 100644
--- a/commands/catalog-entity.go
+++ b/commands/catalog-entity.go
@@ -12,4 +12,4 @@ func NewCatalogEntity(network *net.Network) (cmd 
*CatalogEntity) {
        cmd = new(CatalogEntity)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/catalog-location.go
----------------------------------------------------------------------
diff --git a/commands/catalog-location.go b/commands/catalog-location.go
index 9f00485..cefa7c6 100644
--- a/commands/catalog-location.go
+++ b/commands/catalog-location.go
@@ -12,4 +12,4 @@ func NewCatalogLocation(network *net.Network) (cmd 
*CatalogLocation) {
        cmd = new(CatalogLocation)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/catalog-locations.go
----------------------------------------------------------------------
diff --git a/commands/catalog-locations.go b/commands/catalog-locations.go
index d46823a..1df897b 100644
--- a/commands/catalog-locations.go
+++ b/commands/catalog-locations.go
@@ -12,4 +12,4 @@ func NewCatalogLocations(network *net.Network) (cmd 
*CatalogLocations) {
        cmd = new(CatalogLocations)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/catalog-policies.go
----------------------------------------------------------------------
diff --git a/commands/catalog-policies.go b/commands/catalog-policies.go
index f96f3e1..3d4903a 100644
--- a/commands/catalog-policies.go
+++ b/commands/catalog-policies.go
@@ -12,4 +12,4 @@ func NewCatalogPolicies(network *net.Network) (cmd 
*CatalogPolicies) {
        cmd = new(CatalogPolicies)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

http://git-wip-us.apache.org/repos/asf/brooklyn-client/blob/63d33d4a/commands/catalog-policy.go
----------------------------------------------------------------------
diff --git a/commands/catalog-policy.go b/commands/catalog-policy.go
index da72711..c02eb9d 100644
--- a/commands/catalog-policy.go
+++ b/commands/catalog-policy.go
@@ -12,4 +12,4 @@ func NewCatalogPolicy(network *net.Network) (cmd 
*CatalogPolicy) {
        cmd = new(CatalogPolicy)
        cmd.network = network
        return
-}
\ No newline at end of file
+}

Reply via email to