This is an automated email from the ASF dual-hosted git repository.
mrutkowski pushed a commit to branch master
in repository
https://gitbox.apache.org/repos/asf/incubator-openwhisk-wskdeploy.git
The following commit(s) were added to refs/heads/master by this push:
new ec49a0a Adding documentation on Sync And Adding package binding to
any /<namespace>/<package> (#823)
ec49a0a is described below
commit ec49a0a61473c038a26661d5f0bfdc30a481c5a9
Author: Priti Desai <[email protected]>
AuthorDate: Wed Mar 28 08:37:03 2018 -0700
Adding documentation on Sync And Adding package binding to any
/<namespace>/<package> (#823)
* adding doc on sync
* adding sycn with dependency
* adding some format changes
* fixing typo
* adding clarification of package binding deps
* moving integration tests around, fixing package binding deps
* renaming integration test
---
deployers/servicedeployer.go | 40 +-
docs/sync_projects_between_client_and_server.md | 412 +++++++++++++++++++++
...aml => 06-manifest-with-single-dependency.yaml} | 8 +-
...dency.yaml => 07-manifest-with-dependency.yaml} | 2 +-
.../managed-deployment/managed-deployment_test.go | 4 +-
wski18n/i18n_resources.go | 34 +-
6 files changed, 456 insertions(+), 44 deletions(-)
diff --git a/deployers/servicedeployer.go b/deployers/servicedeployer.go
index 2d417b0..e35fe96 100644
--- a/deployers/servicedeployer.go
+++ b/deployers/servicedeployer.go
@@ -645,33 +645,33 @@ func (deployer *ServiceDeployer)
RefreshManagedPackagesWithDependencies(ma map[s
// for example, "helloworld" where the package it depends on is
also called "helloworld"
// dependencies could be labeled different from the dependent
package name
// for example, "custom-helloworld" where the package it
depends on it called "helloworld"
- for n := range p.Dependencies {
- // find the package using dependency label
- pkg, _, err := deployer.Client.Packages.Get(n)
- if err != nil {
- return err
- }
- // if dependency label (custom-helloworld) is different
from the dependent package name,
- // it must have binding set to the original package
("helloworld")
- if len(pkg.Binding.Name) != 0 {
- // having dependency on packages under
/whisk.system is treated in a different way
- // in which dependent package under
/whisk.system are not modified to add managed annotation
- // and parent package does not show this
dependency in its managed annotation
- // because whisk.system packages comes
pre-packaged and deployed with OpenWhisk server and not
- // deployed along with application deployments.
- // (TODO) here, we are only finding a package
with its name as Get method
- // (TODO) does not support looking under
different/seperate namespace
- // (TODO) we could add support to sync
dependencies from different namespaces in future
- if pkg.Binding.Namespace != utils.WHISK_SYSTEM {
+ for label, n := range p.Dependencies {
+ // we do not append dependencies in whisk-managed in
case of a package binding
+ // for example when a package has dependencies on
/whisk.system/ or any other /<namespace>/
+ // the dependent packages are pre-installed and should
not be managed by current project
+ if !n.IsBinding {
+ // find the package using dependency label
+ pkg, _, err :=
deployer.Client.Packages.Get(label)
+ if err != nil {
+ return err
+ }
+ // if dependency label (custom-helloworld) is
different from the dependent package name,
+ // it must have binding set to the original
package ("helloworld")
+ if len(pkg.Binding.Name) != 0 {
+ // having dependency on packages under
/whisk.system is treated in a different way
+ // in which dependent package under
/whisk.system are not modified to add managed annotation
+ // and parent package does not show
this dependency in its managed annotation
+ // because whisk.system packages comes
pre-packaged and deployed with OpenWhisk server and not
+ // deployed along with application
deployments.
// get the original package to retrieve
its managed annotations
pkg, _, err :=
deployer.Client.Packages.Get(pkg.Binding.Name)
if err != nil {
return err
}
dependencyAnnotations =
deployer.appendDepAnnotation(dependencyAnnotations, pkg)
+ } else {
+ dependencyAnnotations =
deployer.appendDepAnnotation(dependencyAnnotations, pkg)
}
- } else {
- dependencyAnnotations =
deployer.appendDepAnnotation(dependencyAnnotations, pkg)
}
}
updatedAnnotation, err := utils.AddDependentAnnotation(ma,
dependencyAnnotations)
diff --git a/docs/sync_projects_between_client_and_server.md
b/docs/sync_projects_between_client_and_server.md
new file mode 100644
index 0000000..4467ff2
--- /dev/null
+++ b/docs/sync_projects_between_client_and_server.md
@@ -0,0 +1,412 @@
+<!--
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
contributor
+# license agreements. See the NOTICE file distributed with this work for
additional
+# information regarding copyright ownership. The ASF licenses this file to you
+# under the Apache License, Version 2.0 (the # "License"); you may not use this
+# file except in compliance with the License. You may obtain a copy of the
License
+# at:
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
distributed
+# under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+# CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+#
+-->
+
+# How to Sync OpenWhisk Projects between Client and Server?
+
+The answer is running Whisk Deploy in `sync` mode.
+
+Whisk Deploy in `sync` mode, deploys all Apache OpenWhisk entities from the
manifest file and attaches an annotation called `whisk-managed` to all entities
from that manifest file. `whisk-managed` annotation contains following keys:
+
+```
+whisk-managed:
+ projectName: <project-name>
+ projectHash: SHA1("OpenWhisk " + <size_of_manifest_file> + "\0" +
<contents_of_manifest_file>)
+ projectDeps: <list of dependent packages>
+ file: Relative path of manifest file on the file system
+```
+
+> Where the text “OpenWhisk” is a constant prefix and “\0” is the NULL
character. The <size_of_manifest_file> and <contents_of_manifest_file> vary
depending on the file.
+
+Now, subsequent deployments of the same project in `sync` mode, calculates a
new `projectHash` on client and compares it with the one on the server for
every entity in that project. This comparision could lead us to following two
scenarios:
+
+* **Scenario 1:** If `projectHash` on client is same as `projectHash` on the
server i.e. there were no changes in the project on the client side, the
project on server side is left as is except wskdeploy redeploys all the
entities from manifest file to capture any changes in deployment file.
+
+* **Scenario 2:** If `projectHash` on client is different from `projectHash`
on the server i.e. there were some changes in the project on the client side,
`wskdeploy` redeploys all the entities from the manifest file on the client and
updates their `projectHash` on the server. `wskdeploy` also searches all the
entities including packages, actions, sequences, rules, and triggers which has
the same `projectName` i.e. it belonged to the same project but has different
`projectHash` i.e. its [...]
+
+Project name in the manifest file is mandatory to sync that project between
the client and the server:
+
+```
+project:
+ name: <project-name>
+ packages:
+ package1:
+ ....
+```
+
+If for some reason, you want to avoid specifying project name in the manifest
file, it can be specified on command line using `--projectname`.
+
+OpenWhisk entities which are deployed using some other tool or automation and
were part of the same project but has been deleted from that project now, are
left unmodified. These kind of entities are classified as external entities and
are not part of sync.
+
+Undeployment of such project can be driven by `wskdeploy` with:
+
+```
+wskdeploy undeploy --projectname <project-name>
+```
+
+Lets look at a sample project to understand sync mode. Whisk Deploy GitHub
repo has a sample project with many different manifest files to demonstrate
sync mode.
+
+#### Step 1: Deploy MyFirstManagedProject using `sync`:
+
+```
+~/wskdeploy sync -m manifest.yaml
+Success: Deployment completed successfully.
+```
+
+Here is a list of entities deployed on OpenWhisk Server:
+
+```
+bx wsk list
+Entities in namespace: guest
+packages
+/guest/ManagedPackage-2 private
+/guest/ManagedPackage-1 private
+actions
+/guest/ManagedPackage-1/ManagedSequence-2 private
sequence
+/guest/ManagedPackage-1/ManagedSequence-1 private
sequence
+/guest/ManagedPackage-2/ManagedSequence-1 private
sequence
+/guest/ManagedPackage-1/HelloWorld-2 private
nodejs:6
+/guest/ManagedPackage-1/HelloWorld-1 private
nodejs:6
+/guest/ManagedPackage-1/HelloWorld-3 private
nodejs:6
+/guest/ManagedPackage-2/HelloWorld-1 private
nodejs:6
+triggers
+/guest/ManagedTrigger-2 private
+/guest/ManagedTrigger-1 private
+rules
+/guest/ManagedRule-2 private
active
+/guest/ManagedRule-1 private
active
+
+```
+
+`whisk-managed` annotation:
+
+```
+bx wsk package get ManagedPackage-1
+...
+ "name": "ManagedPackage-1",
+ "annotations": [
+ {
+ "key": "whisk-managed",
+ "value": {
+ "file": "manifest.yaml",
+ "projectDeps": [],
+ "projectHash": "d164caed3ab86106495b3963232c4840429df8ea",
+ "projectName": "MyFirstManagedProject"
+ }
+ }
+```
+
+#### Step 2: Sync Client and Server — Deleting ManagedPackage-2
+
+```
+~/wskdeploy sync -m 00-manifest-minus-second-package.yaml
+Deployment completed successfully.
+```
+
+Here is a list of entities deployed on OpenWhisk Server:
+
+```
+bx wsk list
+Entities in namespace: guest
+packages
+/guest/ManagedPackage-1 private
+actions
+/guest/ManagedPackage-1/ManagedSequence-2 private
sequence
+/guest/ManagedPackage-1/ManagedSequence-1 private
sequence
+/guest/ManagedPackage-1/HelloWorld-3 private
nodejs:6
+/guest/ManagedPackage-1/HelloWorld-2 private
nodejs:6
+/guest/ManagedPackage-1/HelloWorld-1 private
nodejs:6
+triggers
+/guest/ManagedTrigger-1 private
+rules
+/guest/ManagedRule-1 private
active
+
+```
+
+#### Step 3: Sync Client and Server — Deleting Sequence ManagedSequence-2
+
+```
+~/wskdeploy sync -m 01-manifest-minus-sequence-2.yaml
+Deployment completed successfully.
+```
+
+Here is a list of entities deployed on OpenWhisk Server:
+
+```
+bx wsk list
+Entities in namespace: guest
+packages
+/guest/ManagedPackage-1 private
+actions
+/guest/ManagedPackage-1/ManagedSequence-1 private
sequence
+/guest/ManagedPackage-1/HelloWorld-3 private
nodejs:6
+/guest/ManagedPackage-1/HelloWorld-2 private
nodejs:6
+/guest/ManagedPackage-1/HelloWorld-1 private
nodejs:6
+triggers
+/guest/ManagedTrigger-1 private
+rules
+/guest/ManagedRule-1 private
active
+```
+
+#### Step 4: Sync Client and Server — Deleting Action Helloworld-3
+
+```
+~/wskdeploy sync -m 02-manifest-minus-action-3.yaml --managed
+Deployment completed successfully.
+```
+
+Here is a list of entities deployed on OpenWhisk Server:
+
+```
+bx wsk list
+Entities in namespace: guest
+packages
+/guest/ManagedPackage-1 private
+actions
+/guest/ManagedPackage-1/ManagedSequence-1 private
sequence
+/guest/ManagedPackage-1/HelloWorld-2 private
nodejs:6
+/guest/ManagedPackage-1/HelloWorld-1 private
nodejs:6
+triggers
+/guest/ManagedTrigger-1 private
+rules
+/guest/ManagedRule-1 private
active
+```
+
+#### Step 5: Sync Client and Server — Deleting ManagedPackage-1 (deleting the
entire project)
+
+```
+~/wskdeploy undeploy --projectname MyFirstManagedProject
+```
+
+## Sync Projects with Dependencies
+
+Now, a question is how does `sync` work in case of a project which has
dependencies. Whisk Deploy supports two different types of dependencies which
are explained [here](../tests/usecases/dependency/README.md). Let's look at how
projects are synced with each type of dependency.
+
+### GitHub Dependency
+
+[Here](../tests/src/integration/managed-deployment/07-manifest-with-dependency.yaml)
is a sample project definition with single dependency:
+
+```
+project:
+ name: MyManagedProjectWithSingleDependency
+ packages:
+ Extension1:
+ dependencies:
+ helloworlds:
+ location:
github.com/pritidesai/incubator-openwhisk-test/packages/helloworlds
+```
+
+After deploying this project with `wskdeploy sync -m manifest.yaml`, package
`Extension2` has following annotation:
+
+```
+bx wsk package get Extension1
+ok: got package Extension1
+{
+ "namespace": "guest",
+ "name": "Extension1",
+ "version": "0.0.2",
+ "publish": false,
+ "annotations": [
+ {
+ "key": "whisk-managed",
+ "value": {
+ "file": "manifest.yaml",
+ "projectDeps": [
+ {
+ "key": "/guest/helloworlds",
+ "value": {
+ "file":
".../src/github.com/apache/incubator-openwhisk-wskdeploy/Packages/helloworlds-master/packages/helloworlds/manifest.yaml",
+ "projectDeps": [],
+ "projectHash":
"0ae33344f7885df01aefd053e94a4eb3675ef72d",
+ "projectName": "HelloWorlds"
+ }
+ }
+ ],
+ "projectHash": "6636904777a298993127202d509d3d405e10592c",
+ "projectName": "MyManagedProjectWithSingleDependency"
+ }
+ }
+ ],
+ "binding": {}
+}
+```
+
+And, dependent package `helloworlds` has following annotation:
+
+```
+bx wsk package get helloworlds
+...
+ "annotations": [
+ {
+ "key": "whisk-managed",
+ "value": {
+ "file":
".../src/github.com/apache/incubator-openwhisk-wskdeploy/Packages/helloworlds-master/packages/helloworlds/manifest.yaml",
+ "projectDeps": [],
+ "projectHash": "0ae33344f7885df01aefd053e94a4eb3675ef72d",
+ "projectName": "HelloWorlds"
+ }
+ }
+ ],
+ "binding": {},
+...
+```
+
+Here, on server side, package `Extension1` is showing dependency on
`helloworlds` using `whisk-managed` annotation.
+
+Now, let's add one more dependency in our project with
[manifest.yaml](../tests/src/integration/managed-deployment/06-manifest-with-single-dependency.yaml):
+
+```
+project:
+ name: MyManagedProjectWithDependency
+ packages:
+ Extension2:
+ dependencies:
+ helloworlds:
+ location:
github.com/pritidesai/incubator-openwhisk-test/packages/helloworlds
+ custom-hellowhisk:
+ location:
github.com/pritidesai/incubator-openwhisk-test/packages/hellowhisk
+...
+```
+
+After deploying this project with `wskdeploy sync -m manifest.yaml`, package
`Extension2` has following annotation:
+
+```
+bx wsk package get Extension2
+ok: got package Extension2
+{
+ "namespace": "guest",
+ "name": "Extension2",
+ "version": "0.0.2",
+ "publish": false,
+ "annotations": [
+ {
+ "key": "whisk-managed",
+ "value": {
+ "file": "manifest.yaml",
+ "projectDeps": [
+ {
+ "key": "/guest/helloworlds",
+ "value": {
+ "file":
".../src/github.com/apache/incubator-openwhisk-wskdeploy/Packages/helloworlds-master/packages/helloworlds/manifest.yaml",
+ "projectDeps": [],
+ "projectHash":
"0ae33344f7885df01aefd053e94a4eb3675ef72d",
+ "projectName": "HelloWorlds"
+ }
+ },
+ {
+ "key": "/guest/hellowhisk",
+ "value": {
+ "file":
"../src/github.com/apache/incubator-openwhisk-wskdeploy/Packages/custom-hellowhisk-master/packages/hellowhisk/manifest.yaml",
+ "projectDeps": [],
+ "projectHash":
"8970b2e820631322ae630e9366b2342ab3b67a57",
+ "projectName": "HelloWhisk"
+ }
+ }
+ ],
+ "projectHash": "554e0aaef1ed2ff0dcf7f68d0c4a8f825d1a49c7",
+ "projectName": "MyManagedProjectWithDependency"
+ }
+ }
+ ],
+ "binding": {}
+}
+```
+
+Here, on server side, package `Extension2` is showing both dependencies (1)
`helloworlds` and (2) `hellowhisk`.
+
+Now, when we try to undeploy `Extension2` using `~/wskdeploy undeploy
--projectname MyManagedProjectWithDependency`, only one dependency `hellowhisk`
is deleted and the other dependency `helloworlds` is not deleted as its
referred by `Extension1`.
+
+> **Note:** Here the dependent package belongs to project `HelloWorlds` which
has a single package `helloworlds`. Whisk Deploy does not support having
dependencies with multiple packages. The reason behind this limitation is when
a dependency is specified in manifest file using label (`custom-hellowhisk`)
which is different than the dependent package name (`hellowhisk`),
`custome-hellowhisk` is created as a binding to `hellowhisk`. OpenWhisk does
not support creating a package which is b [...]
+
+### Package Binding
+
+When a project has dependency to any already deployed package/utility, for
example, `/whisk.system/utils` or any `/<namespace>/<package>`:
+
+```
+project:
+ name: MyManagedProjectWithWhiskSystemDependency
+ packages:
+ Extension3:
+ dependencies:
+ whiskUtility:
+ location: /whisk.system/utils
+ triggers:
+ triggerInExtension3:
+ rules:
+ ruleInExtension3:
+ trigger: triggerInExtension3
+ action: whiskUtility/sort
+```
+
+For these kind of references, dependent package (`/whisk.system/utils` in our
example) is not listed as one of the dependencies since the dependent package
is part of a catalog and was pre-installed therefore cannot be managed by the
current project:
+
+```
+bx wsk package get Extension3
+ok: got package Extension3
+{
+ "namespace": "guest",
+ "name": "Extension3",
+ "version": "0.0.2",
+ "publish": false,
+ "annotations": [
+ {
+ "key": "whisk-managed",
+ "value": {
+ "file": "manifest.yaml",
+ "projectDeps": [],
+ "projectHash": "f5ec911a4e3f011343e4bb0af1900dda3279be75",
+ "projectName": "MyManagedProjectWithWhiskSystemDependency"
+ }
+ }
+ ],
+ "binding": {}
+}
+```
+
+Here, `whiskUtility` is a binding to package `/whisk.system/utils` and part of
the current project. This signifies that `Extension3` has a dependency on a
pre-installed package `/whisk.system/utils`:
+
+```
+bx wsk package get whiskUtility
+ok: got package whiskUtility
+{
+ "namespace": "guest",
+ "name": "whiskUtility",
+ "version": "0.0.1",
+ "publish": false,
+ "annotations": [
+ {
+ "key": "whisk-managed",
+ "value": {
+ "file":
"tests/src/integration/managed-deployment/08-manifest-with-dependencies-on-whisk-system.yaml",
+ "projectDeps": [],
+ "projectHash": "f5ec911a4e3f011343e4bb0af1900dda3279be75",
+ "projectName": "MyManagedProjectWithWhiskSystemDependency"
+ }
+ },
+ {
+ "key": "binding",
+ "value": {
+ "name": "utils",
+ "namespace": "whisk.system"
+ }
+ }
+ ],
+...
+```
+
+Now, when we undeploy `Extension3` with `~/wskdeploy undeploy --projectname
MyManagedProjectWithWhiskSystemDependency`, nothing changes under
`/whisk.system`. `utils` package under `/whisk.system` remains undeployed.
Similarly, with an undeployment of `Extension3`, `/<namespace>/<package>` is
not deleted.
+
diff --git
a/tests/src/integration/managed-deployment/07-manifest-with-single-dependency.yaml
b/tests/src/integration/managed-deployment/06-manifest-with-single-dependency.yaml
similarity index 88%
rename from
tests/src/integration/managed-deployment/07-manifest-with-single-dependency.yaml
rename to
tests/src/integration/managed-deployment/06-manifest-with-single-dependency.yaml
index 903fd0e..ec2241c 100644
---
a/tests/src/integration/managed-deployment/07-manifest-with-single-dependency.yaml
+++
b/tests/src/integration/managed-deployment/06-manifest-with-single-dependency.yaml
@@ -17,13 +17,13 @@
project:
name: MyManagedProjectWithSingleDependency
packages:
- Extension2:
+ Extension1:
dependencies:
helloworlds:
location:
github.com/pritidesai/incubator-openwhisk-test/packages/helloworlds
triggers:
- triggerInExtension2:
+ triggerInExtension1:
rules:
- ruleInExtension2:
- trigger: triggerInExtension2
+ ruleInExtension1:
+ trigger: triggerInExtension1
action: helloworlds/helloworld-js
diff --git
a/tests/src/integration/managed-deployment/06-manifest-with-dependency.yaml
b/tests/src/integration/managed-deployment/07-manifest-with-dependency.yaml
similarity index 98%
rename from
tests/src/integration/managed-deployment/06-manifest-with-dependency.yaml
rename to
tests/src/integration/managed-deployment/07-manifest-with-dependency.yaml
index 0cbe848..c9427c0 100644
--- a/tests/src/integration/managed-deployment/06-manifest-with-dependency.yaml
+++ b/tests/src/integration/managed-deployment/07-manifest-with-dependency.yaml
@@ -17,7 +17,7 @@
project:
name: MyManagedProjectWithDependency
packages:
- Extension1:
+ Extension2:
dependencies:
helloworlds:
location:
github.com/pritidesai/incubator-openwhisk-test/packages/helloworlds
diff --git
a/tests/src/integration/managed-deployment/managed-deployment_test.go
b/tests/src/integration/managed-deployment/managed-deployment_test.go
index 475ab71..c228f98 100644
--- a/tests/src/integration/managed-deployment/managed-deployment_test.go
+++ b/tests/src/integration/managed-deployment/managed-deployment_test.go
@@ -65,7 +65,7 @@ func TestManagedDeployment(t *testing.T) {
}
func TestManagedDeploymentWithDependency(t *testing.T) {
- manifestPath := os.Getenv("GOPATH") + PATH +
"06-manifest-with-dependency.yaml"
+ manifestPath := os.Getenv("GOPATH") + PATH +
"06-manifest-with-single-dependency.yaml"
deploymentPath := ""
wskdeploy := common.NewWskdeploy()
_, err := wskdeploy.ManagedDeployment(manifestPath, deploymentPath)
@@ -73,7 +73,7 @@ func TestManagedDeploymentWithDependency(t *testing.T) {
_, err = wskdeploy.Undeploy(manifestPath, deploymentPath)
assert.Equal(t, nil, err, "Failed to deploy based on the manifest and
deployment files.")
- manifestPath = os.Getenv("GOPATH") + PATH +
"07-manifest-with-single-dependency.yaml"
+ manifestPath = os.Getenv("GOPATH") + PATH +
"07-manifest-with-dependency.yaml"
_, err = wskdeploy.ManagedDeployment(manifestPath, deploymentPath)
assert.Equal(t, nil, err, "Failed to deploy based on the manifest and
deployment files.")
_, err = wskdeploy.Undeploy(manifestPath, deploymentPath)
diff --git a/wski18n/i18n_resources.go b/wski18n/i18n_resources.go
index a28d6b9..2f6894b 100644
--- a/wski18n/i18n_resources.go
+++ b/wski18n/i18n_resources.go
@@ -329,14 +329,14 @@ func AssetNames() []string {
// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
- "wski18n/resources/de_DE.all.json": wski18nResourcesDe_deAllJson,
- "wski18n/resources/en_US.all.json": wski18nResourcesEn_usAllJson,
- "wski18n/resources/es_ES.all.json": wski18nResourcesEs_esAllJson,
- "wski18n/resources/fr_FR.all.json": wski18nResourcesFr_frAllJson,
- "wski18n/resources/it_IT.all.json": wski18nResourcesIt_itAllJson,
- "wski18n/resources/ja_JA.all.json": wski18nResourcesJa_jaAllJson,
- "wski18n/resources/ko_KR.all.json": wski18nResourcesKo_krAllJson,
- "wski18n/resources/pt_BR.all.json": wski18nResourcesPt_brAllJson,
+ "wski18n/resources/de_DE.all.json": wski18nResourcesDe_deAllJson,
+ "wski18n/resources/en_US.all.json": wski18nResourcesEn_usAllJson,
+ "wski18n/resources/es_ES.all.json": wski18nResourcesEs_esAllJson,
+ "wski18n/resources/fr_FR.all.json": wski18nResourcesFr_frAllJson,
+ "wski18n/resources/it_IT.all.json": wski18nResourcesIt_itAllJson,
+ "wski18n/resources/ja_JA.all.json": wski18nResourcesJa_jaAllJson,
+ "wski18n/resources/ko_KR.all.json": wski18nResourcesKo_krAllJson,
+ "wski18n/resources/pt_BR.all.json": wski18nResourcesPt_brAllJson,
"wski18n/resources/zh_Hans.all.json": wski18nResourcesZh_hansAllJson,
"wski18n/resources/zh_Hant.all.json": wski18nResourcesZh_hantAllJson,
}
@@ -380,17 +380,18 @@ type bintree struct {
Func func() (*asset, error)
Children map[string]*bintree
}
+
var _bintree = &bintree{nil, map[string]*bintree{
"wski18n": &bintree{nil, map[string]*bintree{
"resources": &bintree{nil, map[string]*bintree{
- "de_DE.all.json":
&bintree{wski18nResourcesDe_deAllJson, map[string]*bintree{}},
- "en_US.all.json":
&bintree{wski18nResourcesEn_usAllJson, map[string]*bintree{}},
- "es_ES.all.json":
&bintree{wski18nResourcesEs_esAllJson, map[string]*bintree{}},
- "fr_FR.all.json":
&bintree{wski18nResourcesFr_frAllJson, map[string]*bintree{}},
- "it_IT.all.json":
&bintree{wski18nResourcesIt_itAllJson, map[string]*bintree{}},
- "ja_JA.all.json":
&bintree{wski18nResourcesJa_jaAllJson, map[string]*bintree{}},
- "ko_KR.all.json":
&bintree{wski18nResourcesKo_krAllJson, map[string]*bintree{}},
- "pt_BR.all.json":
&bintree{wski18nResourcesPt_brAllJson, map[string]*bintree{}},
+ "de_DE.all.json":
&bintree{wski18nResourcesDe_deAllJson, map[string]*bintree{}},
+ "en_US.all.json":
&bintree{wski18nResourcesEn_usAllJson, map[string]*bintree{}},
+ "es_ES.all.json":
&bintree{wski18nResourcesEs_esAllJson, map[string]*bintree{}},
+ "fr_FR.all.json":
&bintree{wski18nResourcesFr_frAllJson, map[string]*bintree{}},
+ "it_IT.all.json":
&bintree{wski18nResourcesIt_itAllJson, map[string]*bintree{}},
+ "ja_JA.all.json":
&bintree{wski18nResourcesJa_jaAllJson, map[string]*bintree{}},
+ "ko_KR.all.json":
&bintree{wski18nResourcesKo_krAllJson, map[string]*bintree{}},
+ "pt_BR.all.json":
&bintree{wski18nResourcesPt_brAllJson, map[string]*bintree{}},
"zh_Hans.all.json":
&bintree{wski18nResourcesZh_hansAllJson, map[string]*bintree{}},
"zh_Hant.all.json":
&bintree{wski18nResourcesZh_hantAllJson, map[string]*bintree{}},
}},
@@ -443,4 +444,3 @@ func _filePath(dir, name string) string {
cannonicalName := strings.Replace(name, "\\", "/", -1)
return filepath.Join(append([]string{dir},
strings.Split(cannonicalName, "/")...)...)
}
-
--
To stop receiving notification emails like this one, please contact
[email protected].
