{namespace keystore}

/***/
{template .soyweb}
  {call buck.page}
    {param title: 'keystore()' /}
    {param prettify: true /}
    {param content}

{call buck.rule}
{param overview}
A <code>keystore()</code> contains the data for a key pair
created by the <code>keytool</code> executable that comes
with the JDK. This is a required input for an {call buck.android_binary /} rule.
{/param}

{param args}

{call buck.arg}
  {param name: 'name' /}
  {param desc}
  The name of the rule.
  {/param}
{/call}

{call buck.arg}
  {param name: 'store' /}
  {param desc}
  The path to the file that contains the key.
  This is the path that was passed as the <code>-keystore</code> argument
  when you ran <code>keytool</code>.
  {/param}
{/call}

{call buck.arg}
  {param name: 'properties' /}
  {param desc}
  The path to the <code>.properties</code> file that contains the following values:
  {literal}<pre class="prettyprint lang-py">
# The value that you passed as the argument to -alias
# when you ran keytool.
key.alias=my_alias

# The value that you entered in response to
# the "Enter keystore password:" prompt.
key.store.password=store_password

# The value that you entered in response to
# the "Enter key password for &lt;my_alias>" prompt.
key.alias.password=alias_password</pre>{/literal}
  {/param}
{/call}

{/param} // close args

{/call} // close buck.rule

    {/param}
  {/call}
{/template}
