diff --git a/tools/package/archetypes/api/src/test/resources/projects/basic/archetype.properties b/tools/package/archetypes/api/src/test/resources/projects/basic/archetype.properties
index f641e66..a1213b4 100644
--- a/tools/package/archetypes/api/src/test/resources/projects/basic/archetype.properties
+++ b/tools/package/archetypes/api/src/test/resources/projects/basic/archetype.properties
@@ -1,3 +1,19 @@
+#
+# Copyright 2014 Open Networking Laboratory
+#
+# Licensed 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.
+#
+
 #Thu Dec 04 09:24:50 PST 2014
 package=it.pkg
 version=0.1-SNAPSHOT
diff --git a/tools/package/archetypes/bundle/pom.xml b/tools/package/archetypes/bundle/pom.xml
index 472fc6e..7173473 100644
--- a/tools/package/archetypes/bundle/pom.xml
+++ b/tools/package/archetypes/bundle/pom.xml
@@ -1,4 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Copyright 2014 Open Networking Laboratory
+  ~
+  ~ Licensed 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.
+  -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
 
diff --git a/tools/package/archetypes/bundle/src/main/resources/META-INF/maven/archetype-metadata.xml b/tools/package/archetypes/bundle/src/main/resources/META-INF/maven/archetype-metadata.xml
index 7ab9be8..b33574a 100644
--- a/tools/package/archetypes/bundle/src/main/resources/META-INF/maven/archetype-metadata.xml
+++ b/tools/package/archetypes/bundle/src/main/resources/META-INF/maven/archetype-metadata.xml
@@ -1,4 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Copyright 2014 Open Networking Laboratory
+  ~
+  ~ Licensed 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.
+  -->
 <archetype-descriptor xsi:schemaLocation="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.0.0 http://maven.apache.org/xsd/archetype-descriptor-1.0.0.xsd" name="onos-bundle"
     xmlns="http://maven.apache.org/plugins/maven-archetype-plugin/archetype-descriptor/1.0.0"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
diff --git a/tools/package/archetypes/bundle/src/test/resources/projects/basic/archetype.properties b/tools/package/archetypes/bundle/src/test/resources/projects/basic/archetype.properties
index f641e66..a1213b4 100644
--- a/tools/package/archetypes/bundle/src/test/resources/projects/basic/archetype.properties
+++ b/tools/package/archetypes/bundle/src/test/resources/projects/basic/archetype.properties
@@ -1,3 +1,19 @@
+#
+# Copyright 2014 Open Networking Laboratory
+#
+# Licensed 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.
+#
+
 #Thu Dec 04 09:24:50 PST 2014
 package=it.pkg
 version=0.1-SNAPSHOT
diff --git a/tools/package/archetypes/cli/src/test/resources/projects/basic/archetype.properties b/tools/package/archetypes/cli/src/test/resources/projects/basic/archetype.properties
index f641e66..a1213b4 100644
--- a/tools/package/archetypes/cli/src/test/resources/projects/basic/archetype.properties
+++ b/tools/package/archetypes/cli/src/test/resources/projects/basic/archetype.properties
@@ -1,3 +1,19 @@
+#
+# Copyright 2014 Open Networking Laboratory
+#
+# Licensed 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.
+#
+
 #Thu Dec 04 09:24:50 PST 2014
 package=it.pkg
 version=0.1-SNAPSHOT
diff --git a/tools/package/branding/pom.xml b/tools/package/branding/pom.xml
index 8795ba7..ca3ff42 100644
--- a/tools/package/branding/pom.xml
+++ b/tools/package/branding/pom.xml
@@ -1,4 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+  ~ Copyright 2014 Open Networking Laboratory
+  ~
+  ~ Licensed 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.
+  -->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
     <modelVersion>4.0.0</modelVersion>
diff --git a/tools/package/branding/src/main/resources/org/apache/karaf/branding/branding.properties b/tools/package/branding/src/main/resources/org/apache/karaf/branding/branding.properties
index 17fe11b..7a9f9f2 100644
--- a/tools/package/branding/src/main/resources/org/apache/karaf/branding/branding.properties
+++ b/tools/package/branding/src/main/resources/org/apache/karaf/branding/branding.properties
@@ -1,3 +1,18 @@
+#
+# Copyright 2014 Open Networking Laboratory
+#
+# Licensed 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.
+#
 welcome = Welcome to Open Network Operating System (ONOS)!\r\n\
 \u001B[1;31m     ____  _  ______  ____   \u001B[0m\r\n\
 \u001B[1;31m    / __ \\/ |/ / __ \\/ __/    \u001B[0m\r\n\
diff --git a/tools/package/etc/hazelcast.xml b/tools/package/etc/hazelcast.xml
index a42cd1a..a137c4b 100644
--- a/tools/package/etc/hazelcast.xml
+++ b/tools/package/etc/hazelcast.xml
@@ -1,12 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
+
 <!--
-  ~ Copyright (c) 2008-2013, Hazelcast, Inc. All Rights Reserved.
+  ~  Copyright (c) 2008-2013, Hazelcast, Inc. All Rights Reserved.
+  ~ Copyright 2014 Open Networking Laboratory
   ~
   ~ Licensed 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
+  ~     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,
