Hi all

I have an app A and a service B, service B is running on the dea
server(ip 10.0.0.254), app A need to connect with service B through tcp, it
works normally in my LAN, but when I push A to cf, it cannot connect to B,
then I execute bin/wsh to get into the container and ping the host ip,
it's unreachable, as below:







*root(a)18mkbd9n808:~# ping 10.0.0.254PING 10.0.0.254 (10.0.0.254) 56(84)
bytes of data.From 10.0.0.254 icmp_seq=1 Destination Port UnreachableFrom
10.0.0.254 icmp_seq=2 Destination Port Unreachable^C--- 10.0.0.254 ping
statistics ---2 packets transmitted, 0 received, +2 errors, 100% packet
loss, time 1002ms*

But if I ping another host in the LAN. it can be reached!!!








*root(a)18mkbd9n808:~# ping 10.0.0.253PING 10.0.0.253 (10.0.0.253) 56(84)
bytes of data.64 bytes from 10.0.0.253 <http://10.0.0.253>: icmp_seq=1
ttl=63 time=1.60 ms64 bytes from 10.0.0.253 <http://10.0.0.253>: icmp_seq=2
ttl=63 time=0.421 ms^C--- 10.0.0.253 ping statistics ---2 packets
transmitted, 2 received, 0% packet loss, time 1001msrtt min/avg/max/mdev =
0.421/1.013/1.606/0.593 ms*

It's wired!!! my cf-release is cf-175 and I have only one dea server.Does
anyone met this situation before? thanks!

Hi All,

I found the issue , got the details from deploy.yml

thanks
Balaramaraju

On Fri, May 22, 2015 at 10:44 AM, Balaramaraju JLSP <balaramaraju(a)gmail.com>
wrote:

Hi All,

using the *https://github.com/yudai/cf_nise_installer
<https://github.com/yudai/cf_nise_installer>* i install local CF and able
to the start services ".\scripts\start.sh"

logs:-

All processes have been started!
-u admin -p c1oudc0w --skip-ssl-validation'ip.io
Download CF CLI from https://github.com/cloudfoundry/cli

but while setting up the endpiont is it failing

vagrant(a)vagrant-ubuntu-trusty-64:/vagrant$ cf api --skip-ssl-validation
https://api.vagrant-ubuntu-tip.io-64.io
Setting api endpoint to https://api.vagrant-ubuntu-trusty-64.io...
FAILED
Error performing request: Get
https://api.vagrant-ubuntu-trusty-64.ip.io/v2/info: dial tcp
50.21.180.100:443: i/o timeout

any help is appreciated .

--
Balaramaraju

--
J L S P Balaramaraju

Hi All,

using the *https://github.com/yudai/cf_nise_installer
<https://github.com/yudai/cf_nise_installer>* i install local CF and able
to the start services ".\scripts\start.sh"

logs:-

All processes have been started!
-u admin -p c1oudc0w --skip-ssl-validation'ip.io
Download CF CLI from https://github.com/cloudfoundry/cli

but while setting up the endpiont is it failing

vagrant(a)vagrant-ubuntu-trusty-64:/vagrant$ cf api --skip-ssl-validation
https://api.vagrant-ubuntu-tip.io-64.io
Setting api endpoint to https://api.vagrant-ubuntu-trusty-64.io...
FAILED
Error performing request: Get
https://api.vagrant-ubuntu-trusty-64.ip.io/v2/info: dial tcp
50.21.180.100:443: i/o timeout

any help is appreciated .

--
Balaramaraju

skinny buildpacks refer to each buildpack no longer shipping old
unsupported or insecure versions of runtimes. you can still customize the
buildpacks to include older runtimes by building the buildpack yourself
with the admin buildpack feature.

On Thu, May 21, 2015 at 7:34 AM, Long Nguyen <long.nguyen11288(a)gmail.com>
wrote:

Wooot! Thanks James. Is skinny just having latest 2 version of language?


On May 21, 2015 at 1:42:11 AM, James Bayer (jbayer(a)pivotal.io) wrote:

more info is coming soon, we don't have all of the release notes published
yet because dieu and shannon are out of the office. i wanted to share the
great news that the new skinny buildpacks reduced the size of cf-release
from 5.2gb -> 3.5gb!

the "what's in the deploy" file is awaiting approval b/c of mailman limits.

thanks buildpacks team!

--
Thank you,

James Bayer
_______________________________________________
cf-dev mailing list
cf-dev(a)lists.cloudfoundry.org
https://lists.cloudfoundry.org/mailman/listinfo/cf-dev

--
Thank you,

James Bayer

Wooot! Thanks James. Is skinny just having latest 2 version of language?

That's an incredible savings and excellent to see, thanks Buildpacks team!
:)

more info is coming soon, we don't have all of the release notes published
yet because dieu and shannon are out of the office. i wanted to share the
great news that the new skinny buildpacks reduced the size of cf-release
from 5.2gb -> 3.5gb!

the "what's in the deploy" file is awaiting approval b/c of mailman limits.

thanks buildpacks team!

--
Thank you,

James Bayer

more info is coming soon, we don't have all of the release notes published
yet because dieu and shannon are out of the office. i wanted to share the
great news that the new skinny buildpacks reduced the size of cf-release
from 5.2gb -> 3.5gb!

thanks buildpacks team!

--
Thank you,

James Bayer

Howdy all,

We had a meeting of the Buildpacks PMC today, which was only lightly
attended and we adjourned quickly.

Permanent notes are at:

https://github.com/cloudfoundry/pmc-notes/blob/master/Buildpacks/2015-05-20-buildpacks.md

but I've helpfully also included a snapshot of those notes below.

Happy Wednesday!
-mike

---

*# Buildpacks PMC Meeting 2015-05-20*

*## Agenda*

1. Update on Java Buildpack (Ryan Morgan)
2. Update on core Buildpacks (Mike Dalessio)
3. Open Discussion


*## Attendees*

* Chip Childers, Cloud Foundry Foundation
* Mike Dalessio, Pivotal (PMC lead)
* Matthew Sykes, IBM


*## Update on Java Buildpack (Ryan Morgan)*

* Added support for Wily Introscope.
* Memory calculator re-written in Go and supports java memory
configuration at startup time rather than staging time. Some details
on this feature were posted to cf-dev by Chris Frost last week.
* Team currently discussing how to 'pin' buildpack dependency versions
to allow for repeatable offline buildpack creation.
* Team also discussing moving from Jenkins to Concourse for CI.

Mike will follow up with the team to discuss how `buildpack-packager`
might be used to pin cached dependencies.


*## Update on core Buildpacks (Mike Dalessio)*

The [binary buildpack][binary] was added into `cf-release` last week
([PR here][binary-pr]), and moved into the `cloudfoundry` github
org. This is the same idea as what's commonly called a "null"
buildpack, where developers can simply execute a binary at runtime.

The [staticfile buildpack][static] was added into `cf-release` last
week ([PR here][static-pr]), and moved into the `cloudfoundry` github
org. Originally created by Dr. Nic, this buildpacks allows a static
website to be published behind nginx, and for nginx to be configured
in a few interesting ways.

At long last, [skinny buildpacks][skinny] made it into `cf-release`
([PRs here][skinny-pr]). There was also some interesting discussion on
the mailing lists, both [old][skinny-thread1] and
[new][skinny-thread2].

Notable near-term goals:

* ability to generate and test CF rootfs-specific binaries; and tooling for
CF operators to do the same
* work more closely with the java-buildpacks team


*## Open Discussion*

Mike: Just want to note that IBM open-sourced their linux-based ASP.NET/Mono
buildpack this week. Looks awesome!

https://github.com/cloudfoundry-community/asp.net5-buildpack

---

[binary]: https://github.com/cloudfoundry/binary-buildpack
[binary-pr]: https://github.com/cloudfoundry/cf-release/pull/677
[static]: https://github.com/cloudfoundry/staticfile-buildpack
[static-pr]: https://github.com/cloudfoundry/cf-release/pull/668
[skinny]:
https://github.com/cloudfoundry-incubator/buildpack-packager/issues/4
[skinny-pr]:
https://github.com/cloudfoundry/cf-release/pulls?utf8=%E2%9C%93&q=is%3Apr+buildpack+skinny+
[skinny-thread1]:
https://groups.google.com/a/cloudfoundry.org/forum/#!searchin/vcap-dev/addressing$20buildpack/vcap-dev/1HmGK4wU3Rc/lk186OOtdbMJ
[skinny-thread2]:
http://lists.cloudfoundry.org/pipermail/cf-dev/2015-May/000005.html

On Thu, May 14, 2015 at 10:23 AM, Daniel Jones <
daniel.jones(a)engineerbetter.com> wrote:

Hi Lari,

Thanks again for your input. Have you seen this problem with versions of
Tomcat before 8.0.20?

David and I think we've narrowed down the issue to a change from using
Tomcat 8.0.18 to 8.0.21. We're running more tests and collaborating with
Pivotal support. We also noticed that non-prod versions of our apps were
taking longer to crash, so it would seem to be activity-related at least.

Since it seems activity related, have you tried monitoring the number of
threads in the JVM?

While you can cap the number of threads Tomcat uses for processing
requests, I don't believe that you can cap the number of threads it's
possible to create in the JVM. The reason I mention this is because each
thread causes the amount of memory required to go up by the thread stack
size (Xss * <threads> = total thread memory). Perhaps as activity
increases, so does the thread count and that's pushing you over the limit.

Are you setting a custom -Xss value or using the default? From memory, the
default is pretty large. If you're not using a custom one, you might try a
smaller one, like 256k and see if that has any impact on the problem.

Alternatively, you could adjust the memory weightings in the build pack so
that heap consumes a smaller amount of the total memory and there's more
memory available for native / stack and other memory.

Do you know how Tomcat's APR/NIO memory gets allocated?

I'm not sure I follow your question, but in terms of NIO I suspect the JVM
is going to handle memory allocation not Tomcat. Given that, I it should
happen just like any other Java code that uses the NIO. APR is unlikely to
be an issue, see my next comment.

Is there a way of telling from pmap whether pages are being used for NIO
buffers or by the APR?

Unless you compile the APR native library and include it with your version
of the build pack, Tomcat's not going to use it. It'll use NIO by default,
with Tomcat version 8. You can confirm by looking at the logs when you
start your app. One of the first things it logs will be the protocol
handler. This is from a test app, where it's using NIO.

Ex:

```
[CONTAINER] org.apache.coyote.http11.Http11NioProtocol INFO
Initializing ProtocolHandler ["http-nio-63227"]
```

Dan

I wonder if the other folks that have reported CF out of memory errors
with later versions of Tomcat are seeing slow creeps in native memory
consumption?

On Mon, May 11, 2015 at 2:19 PM, Lari Hotari <Lari(a)hotari.net> wrote:

fyi. Tomcat 8.0.20 might be consuming more memory than 8.0.18:

https://github.com/cloudfoundry/java-buildpack/issues/166#issuecomment-94517568

Other things we’ve tried:

- We set verbose garbage collection to verify there was no
memory size issues within the JVM. There wasn’t.

- We tried setting minimum memory for native, it had no effect.
The container still gets killed

- We tried adjusting the ‘memory heuristics’ so that they added
up to 80 rather than 100. This had the effect of causing a delay in the
container being killed. However it still was killed.

I think adjusting memory heuristics so that they add up to 80 doesn't
make a difference because the values aren't percentages.
The values are proportional weighting values used in the memory
calculation:

https://github.com/grails-samples/java-buildpack/blob/b4abf89/docs/jre-oracle_jre.md#memory-calculation

I found out that the only way to reserve "unused" memory is to set a high
value for the native memory lower bound in the memory_sizes.native setting
of config/open_jdk_jre.yml .
Example:

https://github.com/grails-samples/java-buildpack/blob/22e0f6a/config/open_jdk_jre.yml#L25



This seems like classic memory leak behaviour to me.

In my case it wasn't a classical Java memory leak, since the Java
application wasn't leaking memory. I was able to confirm this by getting
some heap dumps with the HeapDumpServlet (
https://github.com/lhotari/java-buildpack-diagnostics-app/blob/master/src/main/groovy/io/github/lhotari/jbpdiagnostics/HeapDumpServlet.groovy)
and analyzing them.

In my case the JVM's RSS memory size is slowly growing. It probably is
some kind of memory leak since one process I've been monitoring now is very
close to the memory limit. The uptime is now almost 3 weeks.

Here is the latest diff of the meminfo report.

https://gist.github.com/lhotari/ee77decc2585f56cf3ad#file-meminfo_diff_example2-txt

From a Java perspective this isn't classical. The JVM heap isn't filling
up. The problem is that RSS size is slowly growing and will eventually
cause the Java process to cross the memory boundary so that the process
gets kill by the Linux kernel cgroups OOM killer.

RSS size might be growing because of many reasons. I have been able to
slow down the growth by doing the various MALLOC_ and JVM parameter tuning
(-XX:MinMetaspaceExpansion=1M -XX:CodeCacheExpansionSize=1M). I'm able to
get a longer uptime, but the problem isn't solved.

Lari



On 15-05-11 06:41 AM, Head-Rapson, David wrote:

Thanks for the continued advice.



We’ve hit on a key discovery after yet another a soak test this weekend.

- When we deploy using Tomcat 8.0.18 we don’t see the issue

- When we deploy using Tomcat 8.0.20 (same app version, same CF
space, same services bound, same JBP code version, same JRE version,
running at the same time), we see the crashes occurring after just a couple
of hours.



Ideally we’d go ahead with the memory calculations you mentioned however
we’re stuck on lucid64 because we’re using Pivotal CF 1.3.x & we’re having
upgrade issues to 1.4.x.

So we’re not able to adjust MALLOC_ARENA_MAX, nor are we able to view RSS
in pmap as you describe



Other things we’ve tried:

- We set verbose garbage collection to verify there was no
memory size issues within the JVM. There wasn’t.

- We tried setting minimum memory for native, it had no effect.
The container still gets killed

- We tried adjusting the ‘memory heuristics’ so that they added
up to 80 rather than 100. This had the effect of causing a delay in the
container being killed. However it still was killed.



This seems like classic memory leak behaviour to me.



*From:* Lari Hotari [mailto:lari.hotari(a)sagire.fi <lari.hotari(a)sagire.fi>]
*On Behalf Of *Lari Hotari
*Sent:* 08 May 2015 16:25
*To:* Daniel Jones; Head-Rapson, David
*Cc:* cf-dev(a)lists.cloudfoundry.org
*Subject:* Re: [Cf-dev] [vcap-dev] Java OOM debugging




For my case, it turned out to be essential to reserve enough memory for
"native" in the JBP. For the 2GB total memory, I set the minimum to 330M.
With that setting I have been able to get over 2 weeks up time by now.

I mentioned this in my previous email:

The workaround for that in my case was to add a native key under
memory_sizes in open_jdk_jre.yml and set the minimum to 330M (that is for a
2GB total memory).
see example
https://github.com/grails-samples/java-buildpack/blob/22e0f6a/config/open_jdk_jre.yml#L25
that was how I got the app I'm running on CF to stay within the memory
bounds. I'm sure there is now also a way to get the keys without forking
the buildpack. I could have also adjusted the percentage portions, but I
wanted to set a hard minimum for this case.


I've been trying to get some insight by diffing the reports gathered from
the meminfo servlet https://github.com/lhotari/java-buildpack-diagnostics-app/blob/master/src/main/groovy/io/github/lhotari/jbpdiagnostics/MemoryInfoServlet.groovy


Here is such an example of a diff:

https://gist.github.com/lhotari/ee77decc2585f56cf3ad#file-meminfo_diff_example-txt

meminfo has pmap output included to get the report of the memory map of
the process. I have just noticed that most of the memory has already been
mmap:ed from the OS and it's just growing in RSS size. For example:
< 00000000a7600000 1471488 1469556 1469556 rw--- [ anon ]

00000000a7600000 1471744 1470444 1470444 rw--- [ anon ]

The pmap output from lucid64 didn't include the RSS size, so you have to
use cflinuxfs2 for this. It's also better because of other reasons. The
glibc in lucid64 is old and has some bugs around the MALLOC_ARENA_MAX.

I was manually able to estimate the maximum size of the RSS size of what
the Java process will consume by simply picking the large anon-blocks from
the pmap report and calculating those blocks by the allocated virtual size
(VSS).
Based on this calculation, I picked the minimum of 330M for "native" in
open_jdk_jre.yml as I mentioned before.

It looks like these rows are for the Heap size:
< 00000000a7600000 1471488 1469556 1469556 rw--- [ anon ]

00000000a7600000 1471744 1470444 1470444 rw--- [ anon ]

It looks like the JVM doesn't fully allocate that block in RSS initially
and most of the growth of RSS size comes from that in my case. In your
case, it might be something different.

I also added a servlet for getting glibc malloc_info statistics in XML
format (). I haven't really analysed that information because of time
constraints and because I don't have a pressing problem any more. btw. The
malloc_info XML report is missing some key elements, that has been added in
later glibc versions (
https://github.com/bminor/glibc/commit/4d653a59ffeae0f46f76a40230e2cfa9587b7e7e
).

If killjava.sh never fires and the app crashed with Warden out of memory
errors, then I believe it's the kernel's cgroups OOM killer that has killed
the container processes. I have found this location where Warden oom
notifier gets the OOM notification event:

https://github.com/cloudfoundry/warden/blob/ad18bff/warden/lib/warden/container/features/mem_limit.rb#L70
This is the oom.c source code:
https://github.com/cloudfoundry/warden/blob/ad18bff7dc56acbc55ff10bcc6045ebdf0b20c97/warden/src/oom/oom.c
. It reads the cgroups control files and receives events from the kernel
that way.

I'd suggest that you use pmap for the Java process after it has started
and calculate the maximum RSS size by calculating the VSS size of the large
anon blocks instead of RSS for the blocks that the Java process has
reserved for it's different memory areas (I think you shouldn't . You
should discard adding VSS for the CompressedClassSpaceSize block.
After this calculation, add enough memory to the "native" parameter in
JBP until the RSS size calculated this way stays under the limit.
That's the only "method" I have come up by now.

It might be required to have some RSS space allocated for any zip/jar
files read by the Java process. I think that Java uses mmap files for zip
file reading by default and that might go on top of all other limits.
To test this theory, I'd suggest testing by adding
-Dsun.zip.disableMemoryMapping=true system property setting to JAVA_OPTS.
That disables the native mmap for zip/jar file reading. I haven't had time
to test this assumption.

I guess the only way to understand how Java allocates memory is to look
at the source code.
from http://openjdk.java.net/projects/jdk8u/ , the instructions to get
the source code of JDK 8:
hg clone http://hg.openjdk.java.net/jdk8u/jdk8u;cd jdk8u;sh
get_source.sh
This tool is really good for grepping and searching the source code:
http://geoff.greer.fm/ag/
On Ubuntu it's in silversearcher-ag package, "apt-get install
silversearcher-ag" and on MacOSX brew it's "brew install
the_silver_searcher".
This alias is pretty useful:
alias codegrep='ag --color --group --pager less -C 5'
Then you just search for the correct location in code by starting with
the tokens you know about:
codegrep MaxMetaspaceSize
this gives pretty good starting points in looking how the JDK allocates
memory.

So the JDK source code is only a few commands away.

It would be interesting to hear more about this if someone has the time
to dig in to this. This is about how far I got and I hope sharing this
information helps someone continue. :)


Lari
github/twitter: lhotari

On 15-05-08 10:02 AM, Daniel Jones wrote:

Hi Lari et al,



Thanks for your help Lari.



David and I are pairing on this issue, and we're yet to resolve it. We're
in the process of creating a repeatable test case (our most crashy app
makes calls to external services that need mocking), but in the meantime,
here's what we've seen.



Between Java Buildpack commit e89e546 and 17162df, we see apps crashing
with Warden out of memory errors. killjava.sh never fires, and this has led
us to believe that the kernel is shooting a cgroup process in the head
after the cgroup oversteps its memory limit. We cannot find any evidence of
the OOM killer firing in any logs, but we may not be looking in the right
place.



The JBP is setting heap to be 70%, metaspace to be 15% (with max set to
the same as initial), 5% for "stack", 5% for "normalised stack" and 10% for
"native". We do not understand why this adds up to 105%, but haven't looked
into the JBP algorithm yet. Any pointers on what "normalised stack" is
would be much appreciated, as this doesn't appear in the list of heuristics
supplied via app env.



Other team members tried applying the same settings that you suggested -
thanks for this. Apps still crash with these settings, albeit less
frequently.



After reading the blog you linked to (
http://java.dzone.com/articles/java-8-permgen-metaspace) we wondered
whether the increased *reserved *metaspace claimed after metaspace GC
might be causing a problem; however we reused the test code to create a
metaspace leak in a CF app and saw metaspace GCs occur correctly, and
memory usage never grow over MaxMetaspaceSize. This figures, as the
committed metaspace is still less than MaxMetaspaceSize, and the reserved
appears to be whatever RAM is free across the whole DEA.



We noted that an Oracle blog (
https://blogs.oracle.com/poonam/entry/about_g1_garbage_collector_permanent)
mentions that the metaspace size parameters are approximate. We're
currently wondering if native allocations by Tomcat (APR, NIO) are taking
up more container memory, and so when the metaspace fills, it's creeping
slightly over the limit and triggering the kernel's OOM killer.



Any suggestions would be much appreciated. We've tried to resist tweaking
heuristics blindly, but are running out of options as we're struggling to
figure out how the Java process is using *committed* memory. pmap seems
to show virtual memory, and so it's hard to see if things like the
metaspace or NIO ByteBuffers are nabbing too much and trigger the kernel's
OOM killer.



Thanks for all your help,



Daniel Jones & David Head-Rapson



On Wed, Apr 29, 2015 at 8:07 PM, Lari Hotari <Lari(a)hotari.net> wrote:

Hi,

I created a few tools to debug OOM problems since the application I was
responsible for running on CF was failing constantly because of OOM
problems. The problems I had, turned out not to be actual memory leaks in
the Java application.

In the "cf events appname" log I would get entries like this:
2015-xx-xxTxx:xx:xx.00-0400 app.crash appname index: 1,
reason: CRASHED, exit_description: out of memory, exit_status: 255

These type of entries are produced when the container goes over it's
memory resource limits. It doesn't mean that there is a memory leak in the
Java application. The container gets killed by the Linux kernel oom killer (
https://github.com/cloudfoundry/warden/blob/master/warden/README.md#limit-handle-mem-value)
based on the resource limits set to the warden container.

The memory limit is specified in number of bytes. It is enforced using
the control group associated with the container. When a container exceeds
this limit, one or more of its processes will be killed by the kernel.
Additionally, the Warden will be notified that an OOM happened and it
subsequently tears down the container.

In my case it never got killed by the killjava.sh script that gets called
in the java-buildpack when an OOM happens in Java.

This is the tool I built to debug the problems:
https://github.com/lhotari/java-buildpack-diagnostics-app
I deployed that app as part of the forked buildpack I'm using.
Please read the readme about what it's limitations are. It worked for me,
but it might not work for you. It's opensource and you can fork it. :)

There is a solution in my toolcase for creating a heapdump and uploading
that to S3:

https://github.com/lhotari/java-buildpack-diagnostics-app/blob/master/src/main/groovy/io/github/lhotari/jbpdiagnostics/HeapDumpServlet.groovy
The readme explains how to setup Amazon S3 keys for this:
https://github.com/lhotari/java-buildpack-diagnostics-app#amazon-s3-setup
Once you get a dump, you can then analyse the dump in a java profiler
tool like YourKit.

I also have a solution that forks the java-buildpack modifies killjava.sh
and adds a script that uploads the heapdump to S3 in the case of OOM:

https://github.com/lhotari/java-buildpack/commit/2d654b80f3bf1a0e0f1bae4f29cb85f56f5f8c46

In java-buildpack-diagnostics-app I have also other tools for getting
Linux operation system specific memory information, for example:


https://github.com/lhotari/java-buildpack-diagnostics-app/blob/master/src/main/groovy/io/github/lhotari/jbpdiagnostics/MemoryInfoServlet.groovy

https://github.com/lhotari/java-buildpack-diagnostics-app/blob/master/src/main/groovy/io/github/lhotari/jbpdiagnostics/MemorySmapServlet.groovy

https://github.com/lhotari/java-buildpack-diagnostics-app/blob/master/src/main/groovy/io/github/lhotari/jbpdiagnostics/MallocInfoServlet.groovy

These tools are handy for looking at details of the Java process RSS
memory usage growth.

There is also a solution for getting ssh shell access inside your
application with tmate.io:

https://github.com/lhotari/java-buildpack-diagnostics-app/blob/master/src/main/groovy/io/github/lhotari/jbpdiagnostics/TmateSshServlet.groovy
(this version is only compatible with the new "cflinuxfs2" stack)

It looks like there are serious problems on CloudFoundry with the memory
sizing calculation. An application that doesn't have a OOM problem will get
killed by the oom killer because the Java process will go over the memory
limits.
I filed this issue:
https://github.com/cloudfoundry/java-buildpack/issues/157 , but that
might not cover everything.

The workaround for that in my case was to add a native key under
memory_sizes in open_jdk_jre.yml and set the minimum to 330M (that is for a
2GB total memory).
see example
https://github.com/grails-samples/java-buildpack/blob/22e0f6a/config/open_jdk_jre.yml#L25
that was how I got the app I'm running on CF to stay within the memory
bounds. I'm sure there is now also a way to get the keys without forking
the buildpack. I could have also adjusted the percentage portions, but I
wanted to set a hard minimum for this case.

It was also required to do some other tuning.

I added this to JAVA_OPTS:
-XX:CompressedClassSpaceSize=256M -XX:InitialCodeCacheSize=64M
-XX:CodeCacheExpansionSize=1M -XX:CodeCacheMinimumFreeSpace=1M
-XX:ReservedCodeCacheSize=200M -XX:MinMetaspaceExpansion=1M
-XX:MaxMetaspaceExpansion=8M -XX:MaxDirectMemorySize=96M
while trying to keep the Java process from growing in RSS memory size.

The memory overhead of a 64 bit Java process on Linux can be reduced by
specifying these environment variables:

stack: cflinuxfs2
.
.
.
env:
MALLOC_ARENA_MAX: 2
MALLOC_MMAP_THRESHOLD_: 131072
MALLOC_TRIM_THRESHOLD_: 131072
MALLOC_TOP_PAD_: 131072
MALLOC_MMAP_MAX_: 65536

MALLOC_ARENA_MAX works only on cflinuxfs2 stack (the lucid64 stack has a
buggy version of glibc).

explanation about MALLOC_ARENA_MAX from Heroku:
https://devcenter.heroku.com/articles/tuning-glibc-memory-behavior
some measurement data how it reduces memory consumption:
https://devcenter.heroku.com/articles/testing-cedar-14-memory-use

I have created a PR to add this to CF java-buildpack:
https://github.com/cloudfoundry/java-buildpack/pull/160

I also created an issues
https://github.com/cloudfoundry/java-buildpack/issues/163 and
https://github.com/cloudfoundry/java-buildpack/pull/159 .

I hope this information helps others struggling with OOM problems in CF.
I'm not saying that this is a ready made solution just for you. YMMV. It
worked for me.

-Lari




On 15-04-29 10:53 AM, Head-Rapson, David wrote:

Hi,

I’m after some guidance on how to get profile Java apps in CF, in order
to get to the bottom of memory issues.

We have an app that’s crashing every few hours with OOM error, most
likely it’s a memory leak.

I’d like to profile the JVM and work out what’s eating memory, however
tools like yourkit require connectivity INTO the JVM server (i.e. the
warden container), either via host / port or via SSH.

Since warden containers cannot be connected to on ports other than for
HTTP and cannot be SSHd to, neither of these works for me.



I tried installed a standalone JDK onto the warden container, however as
soon as I ran ‘jmap’ to invoke the dump, warden cleaned up the container –
most likely for memory over-consumption.



I had previously found a hack in the Weblogic buildpack (
https://github.com/pivotal-cf/weblogic-buildpack/blob/master/docs/container-wls-monitoring.md)
for modifying the start script which, when used with
–XX:HeapDumpOnOutOfMemoryError, should copy any heapdump files to a file
share somewhere. I have my own custom buildpack so I could use something
similar.

Has anyone got a better solution than this?



We would love to use newrelic / app dynamics for this however we’re not
allowed. And I’m not 100% certain they could help with this either.



Dave



The information transmitted is intended for the person or entity to which
it is addressed and may contain confidential, privileged or copyrighted
material. If you receive this in error, please contact the sender and
delete the material from any computer. Fidelity only gives information on
products and services and does not give investment advice to retail clients
based on individual circumstances. Any comments or statements made are not
necessarily those of Fidelity. All e-mails may be monitored. FIL
Investments International (Reg. No.1448245), FIL Investment Services (UK)
Limited (Reg. No. 2016555), FIL Pensions Management (Reg. No. 2015142) and
Financial Administration Services Limited (Reg. No. 1629709) are authorised
and regulated in the UK by the Financial Conduct Authority. FIL Life
Insurance Limited (Reg No. 3406905) is authorised in the UK by the
Prudential Regulation Authority and regulated in the UK by the Financial
Conduct Authority and the Prudential Regulation Authority. Registered
offices at Oakhill House, 130 Tonbridge Road, Hildenborough, Tonbridge,
Kent TN11 9DZ.

--
You received this message because you are subscribed to the Google Groups
"Cloud Foundry Developers" group.
To view this discussion on the web visit
https://groups.google.com/a/cloudfoundry.org/d/msgid/vcap-dev/DFFA4ADB9F3BC34194429921AB329336408CAB04%40UKFIL7006WIN.intl.intlroot.fid-intl.com
<https://groups.google.com/a/cloudfoundry.org/d/msgid/vcap-dev/DFFA4ADB9F3BC34194429921AB329336408CAB04%40UKFIL7006WIN.intl.intlroot.fid-intl.com?utm_medium=email&utm_source=footer>
.
To unsubscribe from this group and stop receiving emails from it, send an
email to vcap-dev+unsubscribe(a)cloudfoundry.org.




_______________________________________________
Cf-dev mailing list
Cf-dev(a)lists.cloudfoundry.org
https://lists.cloudfoundry.org/mailman/listinfo/cf-dev





--

Regards,



Daniel Jones

EngineerBetter.com

--
Regards,

Daniel Jones
EngineerBetter.com

_______________________________________________
cf-dev mailing list
cf-dev(a)lists.cloudfoundry.org
https://lists.cloudfoundry.org/mailman/listinfo/cf-dev

On Thu, May 14, 2015 at 2:59 PM, Lari Hotari <Lari(a)hotari.net> wrote:

On 15-05-14 10:23 AM, Daniel Jones wrote:

Thanks again for your input. Have you seen this problem with versions
of Tomcat before 8.0.20?

I don't have proper data gathered from older than 8.0.20, so I cannot
compare.
I was just wondering when did 8.0.20 become available in JBP, I found
this date:
HEAD https://download.run.pivotal.io/tomcat/tomcat-8.0.20.tar.gz | grep
Last-Modified
Last-Modified: Tue, 03 Mar 2015 11:35:19 GMT

David and I think we've narrowed down the issue to a change from using
Tomcat 8.0.18 to 8.0.21. We're running more tests and collaborating
with Pivotal support. We also noticed that non-prod versions of our
apps were taking longer to crash, so it would seem to be
activity-related at least.

Do you know how Tomcat's APR/NIO memory gets allocated? Is there a way
of telling from pmap whether pages are being used for NIO buffers or
by the APR?

I don't think you can get the info from pmap. The malloc_info xml shows
better allocation stats, but only stats.
Is Tomcat using APR library or NIO by default in CloudFoundry? I'd
assume that NIO isn't used by default.

Sorry for the duplicate. Resending as my first reply didn't go back to the
list.

Since the Connector in server.xml is not specifically setting an
implementation it should use the NIO connector, which is the default in
Tomcat 8. A quick test on PWS confirmed this for me.


https://github.com/cloudfoundry/java-buildpack/blob/master/resources/tomcat/conf/server.xml#L22

It would be interesting to see if the BIO or APR connectors have similar
issues. BIO would be easy to test, just add
`protocol="org.apache.coyote.http11.Http11Protocol"` to the Connector tag
on line #22.

APR would be trickier as you'd need to compile the native library and pull
that into the environment.

Dan

Have you tried the "-Dsun.zip.disableMemoryMapping=true" JVM option to
rule out the possibility that zip/jar file access is causing the
trouble? There has been some bugs in the past in the JVM in that area:

http://javaeesupportpatterns.blogspot.com.es/2011/08/mmap-file-outofmemoryerror-and-pmap.html
. That has been fixed
http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6280693 , but doing
a check with "-Dsun.zip.disableMemoryMapping=true" JVM option would be
interesting.
Mainly concerned about this commit:

https://github.com/apache/tomcat/commit/6e5420c67fbad81973d888ad3701a392fac4fc71

Since most commits weren't very interesting in this diff:
https://github.com/apache/tomcat/compare/075bc2d6...c0eb033f?w=1
Might make a difference to Jar file access. I'm not saying that this
commit is a problem, just seemed like a big change.

-Lari
_______________________________________________
cf-dev mailing list
cf-dev(a)lists.cloudfoundry.org
https://lists.cloudfoundry.org/mailman/listinfo/cf-dev

On behalf of the CF Core Services team, I am pleased to announce v10 of
cf-riak-cs-release <https://github.com/cloudfoundry/cf-riak-cs-release>.

cf-riak-cs-release <https://github.com/cloudfoundry/cf-riak-cs-release> is
a BOSH release that delivers an S3-compatible, highly available object
store-as-a-service for Cloud Foundry. Through Cloud Foundry, users can
provision S3-style buckets and deliver unique credentials to bound
applications.

v10 is a minor update, mostly enabling additional security and some
additional documentation:
- Default to SSL endpoints for communication between Cloud Controller and
Broker. 93485814 <https://www.pivotaltracker.com/story/show/93485814>
- Improve documentation around contributions. 90029504
<https://www.pivotaltracker.com/story/show/90029504>
- Expose ssl_enabled flag to enforce SSL. 80055322
<https://www.pivotaltracker.com/story/show/93485814>
- Addition of a small utility script to run the broker-registrar errand
on bosh-lite.
- Deployment manifest stub changes

We've also promoted the domain properties to top-level properties in
manifests:
- domain is now .properties.domain
- meta.cf.apps_domain is now .properties.app_domains.[0]

All this and more can be found on Github
<https://github.com/cloudfoundry/cf-riak-cs-release> and bosh.io
<http://bosh.io/releases/github.com/cloudfoundry/cf-riak-cs-release?version=10>
<http:>.

--
Marco Nicosia
Product Manager
Pivotal Software, Inc.

I finally got around to using this tool. Don't know why it took me so
long. :) Nice work Ben!

Mike

Hi all,

We had a meeting of the Utilities PMC today, permanent notes are at:

https://github.com/cloudfoundry/pmc-notes/blob/master/Utilities/2015-05-19-utilities.md

I've copied the notes below.

-mike


----

*# Utilities PMC Meeting 2015-05-19*

*## Agenda*

1. Update on CI tools (Mike Dalessio)
2. Update on CLI (Greg Oehman)
3. Update on Eclipse plugin and Java tools (Ryan Morgan)
4. Proposal to move `pivotal-cf-experimental/jibber_jabber` into
`cloudfoundry-incubator`
5. Incubating HP projects: Next steps
6. Open Discussion


*## Attendees*

- Chip Childers, Cloud Foundry Foundation
- Mike Dalessio, Pivotal (PMC lead)
- Gert Drapers, HP
- Ryan Morgan, Pivotal


*## Update on CI tools (Mike Dalessio)*

The Toolsmiths team is considering two new tracks of work:

__"krafa"__ is a simple web server and CLI tool used to manage a pool
of CF environments. Pipelines can "reserve" an environment for the
duration of its build, and then release it back into the
pool. Environments can have tags that can be filtered against in a
reservation query.

We're also considering a track of work that would examine a project's
source tree, discover dependencies (and locked versions of those
dependencies), and then check a NIST database for vulnerabilities in
those dependencies. This may end up as a docker image that can be
added to a Concourse pipeline, and may be extended to include other
security checks.

__Chip__ suggested that we should talk to Intel about their tools as
well. Chip will try to find the right contact there for a
conversation.

__Gert__ asked about code-style enforcement tools on C# projects. He
will send some information on what HP is using.


*## Update on CLI (Greg Oehman)*

Agenda item skipped, as both Greg and Michael Fraenkel are traveling.


*## Update on Eclipse plugin and Java tools (Ryan Morgan)*

* Eclipse tooling 1.8.2 released last week, enabling JRebel remoting. Was
demoed at summit.
- Video is being made to explain how to use JRebel with a CF app. URL
forthcoming when it's done.

* Proposal for moving the plugin to the Eclipse Foundation has been
completed, awaiting input from Chip.

* Started work on what will be the 1.8.3 release
- Exploring using Diego SSH access to debug without a sidecar process.


*## Proposal to move `pivotal-cf-experimental/jibber_jabber` into
`cloudfoundry-incubator`*

`jibber_jabber` provides i18n support to the CLI. It's being proposed to
incubate it.

Chip weighed in that we're still unwinding things from the Foundation
spinout, so let's just move it in and move on.

Action item:

- [ ] Mike will move this repo into `cloudfoundry-incubator`


*## Incubating HP projects: Next steps*

Several repositories are being incubated as of CF Summit:

* [Visual Studio plugin][vsp]
* [MSBuild tasks][msbuild]
* [.NET SDK][sdk]

After some discussion, it was decided to put all three repos under a single
umbrella project.

[vsp]: https://github.com/cloudfoundry-incubator/cf-vs-extension
[msbuild]: https://github.com/cloudfoundry-incubator/cf-msbuild-tasks
[sdk]: https://github.com/cloudfoundry-incubator/cf-dotnet-sdk

Chip provided some context around what a "project" is, in that he
views it as a backlog of work, and not necessarily a 1-to-1
relationship with a code repository.

HP's team will work via a distributed committer model for the time
being. Gert will provide details around who is the PM, and who the
approved committers are. Mike will create a public Pivotal Tracker
project, and Chip will create a Github team for the repositories.

HP will maintain downstream forks of the incubating repositories for
now, so that they can sign their binaries for their product.

Action Items:

- [ ] Gert to provide a list of approved committers
- [ ] Mike Dalessio to create a public Tracker project and add people
- [ ] Chip to create a Github team to commit to the cf-incubator org
repositories


*## Open Discussion*

No other topics raised.

Hi John,

James is correct, the resources do not get cleaned up. The system does not
have any runtime dependencies on any of them however. They are used when
pushing an app to prevent the user from having to push a large file that
the system has already seen.

You should be able to delete the contents of the resources blobstore. This
is the path defined by
properties.cc.resource_pool.resource_directory_key in your deployment
manifest.

Removing anything in the buildpacks, droplets, or packages folders can
cause problems in the running system.

- CF Runtime Team

john, i think the resource files may grow forever right now without
intervention.

i'm pretty confident that when apps are deleted that their droplets are
deleted with them and that proper garbage collection occurs with that.

i'm unaware of any NFS file system to s3 blob migration. you would need to
update the CC_DB references too i'm pretty sure. i'm interested if you

find

out more.

On Tue, May 5, 2015 at 1:14 PM, John Wong <gokoproject at gmail.com>

wrote:

> Hi

> I just looked at our disk usage on NFS server. We have used like 200G

so

far, and I wonder if there's a systematic way to purge files we don't

need

(or how do I know I don't need them)?

Similarly, if I were to replace NFS server with S3 instead, does the
existing process (if any) work with S3?

Thanks.

_______________________________________________
cf-dev mailing list
cf-dev at lists.cloudfoundry.org
https://lists.cloudfoundry.org/mailman/listinfo/cf-dev

--
Thank you,

James Bayer

i strongly recommend that you move on to cf v2 for new deployments. cf v1
has not been actively maintained for quite some time.

--
Thank you,

James Bayer

this email list is about cloud foundry oss, not pivotal commercial
software. you can always open a support case at pivotal.io/support for
commercial product inquiries.

the pcf mysql product is based on the oss cf mysql [1]. for each bosh
deployment of mysql you get a mysql compatible cluster. the cluster uses
mariadb and galera for the database nodes. the default configurations for
tunable parameters are listed in the spec file:
https://github.com/cloudfoundry/cf-mysql-release/blob/master/jobs/mysql/spec

what those values should be for your deployment and application workloads
are going to be highly dependent on what tradeoffs you want to make. the
service plan you use should indicate the number of connections available
with your plan, and how you configure max connections in your application
typically depends on the database access framework you use.

[1] github.com/cloudfoundry/cf-mysql-release

--
Thank you,

James Bayer

Thank you for your answers.

Cloud Foundry v1 (dev_setup) is no longer supported

http://grokbase.com/t/cloudfoundry.org/vcap-dev/13bd5tmwh2/got-error-error-installing-chef-during-vcap-installation

2015-05-19 17:05 GMT+09:00 张祥 <zx1084583686(a)gmail.com>:

when i install the cloudfoundry v1,i met a problem,could you help me ?
[image: 内嵌图片 1]