vcap | Cloud Foundry - the open platform as a service project | Microservice library

Diego Cells stage apps and upload droplet to blobstore via cloud controller, the max file can be uploaded is configurable at Ops Manager > TAS for VMs > Application Developer Control > Maximum File Upload Size (MB), default is 1024MB. Seems this is causing restriction, if you can get it increased with your admin help...

Tasks run in their own containers so possibly not an option. I think Python buildpack collects and install the packages before creating the droplet, so don't think copying packages directly to /app directory will be of much help.

If you have data files then you can use .profile file and do some scripting to copy them from S3 or server/NFS location into the /app directory. Something like

Not 100% sure this will resolve the issue, but here's what I've seen commonly trip people up trying to vendor Node.js dependencies:

First, review the instructions from the docs: https://docs.cloudfoundry.org/buildpacks/node/index.html#vendoring

1. Run npm install (you've done this)
2. Make sure you have a package-lock.json file (you probably have this). That locks in the versions to use and should guarantee what's in node_modules/ matches what will be installed. If you don't have this, you'll see Warning: package-lock.json not found. output from the buildpack.
3. Make sure you're pushing up package.json, package-lock.json, and the full node_modules/ directory, along with all your application code.

These are not documented, but some tips from what I've observed working with others on this:

1. Make sure you don't have a .cfignore file, as that could accidentally cause node_modules/ to not be pushed. You can typically tell if node_modules/ is not being pushed because the number of files & size of what is being pushed will be much, much larger with this. You will also see the message It is recommended to vendor the application's Node.js dependencies if the node_modules/ directory doesn't exist.

2. When you run npm install locally, you need to be running it in an Ubuntu Bionic VM or container. This is because NPM will often install modules that require native code. It will automatically handle this, but what's in node_modules/ is specific for the OS & architecture where you run npm install. Thus If you run npm install on a non-Ubuntu Bionic OS (say Windows or MacOS), it will compile the native code for your local machine. When you push this up, it won't match and NPM will try to reinstall the package which can trigger access to the Internet.

3. Make sure you're using the latest Node.js buildpack & Node.js version as possible. It always helps to have the latest code with bug fixes.

4. NODE_ENV=production will be set by the buildpack, and this can sometimes cause difference in behavior. It also skips installing dev dependencies. Not likely the issue here, but worth mentioning as this trips up some people.

Try this once:

Your Dockerfile is for running the app as container. With Cloud Foundry you need to really have a requirements.txt with all the modules your app depends on. You also need a runtime.txt to specify the Python version. Check out this Cloud Foundry documentation on the Python buildpack and the required configuration files.

The Ruby buildpack cannot carry every single version of Ruby & bundler, it would make for an extremely large buildpack. Due to this, all buildpacks will only retain a select set of versions of the software they include in each version of the buildpack. Buildpacks are meant to encourage you to keep up with the latest versions of your software, so buildpacks will drop older versions of software as the buildpacks are updated & new releases are cut.

This means you have three choices:

1. You can look at the release notes for your buildpack or the build pack dependency viewer to see buildpack versions contain the specific versions of software you require.

   For example, if you must have bundler 2.1.4, then you'd need to look and find the latest buildpack version which contains it. Hint, it's v1.8.27. You can confirm the same info using the buildpack release notes also.

   Once you find the specific buildpack version, then you need to tell Cloud Foundry that you want that version of the buildpack, which contains the version of the software you require. For example: cf push -b https://github.com/cloudfoundry/ruby-buildpack#v1.8.27.

   This has some drawbacks though, a.) Cloud Foundry must be able to talk to the Internet and download that buildpack and b.) you're stuck with the versions of software in that buildpack, so your app may be vulnerable to security issues that have already been resolved in newer versions of software installed by the buildpack.

2. Most of the time you don't care about the exact specific version of Ruby, Bundler, or other libraries, and what you want is to declare a more flexible version in your project, like "I want Bundler 2". At which point, you'll just get the latest Bundler 2.x.y version supported, so long as the buildpack you're using still includes some version of Bundler 2 (even major versions will roll-off over time).

3. If you feel like you do need to continue specifying an exact version of Bundler (or other software), you will need to periodically update your application and the versions of software it uses to work with the more recent versions installed by the buildpack.

   For example, the latest Ruby buildpack as I write this, 1.8.32, includes Bundler 2.2.11. That would mean you'd need to update your app to expect and work with this version.

In general, the most friction-free & safe option is #2. You'll continue to get updates to your software and it should continue to deploy without issue. The downside is that you may over time get an update that's incompatible with your app. You'd then have to fix that before you can continue deploying your app.

Option #3 is also OK, but it requires a lot of micromanagement. If you don't really need that level of control, I would suggest going with option #2. You'll get similar results and it'll be less effort.

Option #1 should be a last resort and only used if your app absolutely has no other option, or perhaps you need to buy some time as you upgrade the app to be compatible with newer versions. This version, over time, will leave your app susceptible to security vulnerabilities.

You might be thinking that this all sounds like a tremendous pain, but it's not. It's the buildpack forcing you to think about your software dependencies and forcing good upgrade hygiene. That is a very good thing, as it will keep your software up-to-date and keep your application protected from vulnerabilities in the software it consumes.

I think the first thing that you should do is to check the ret. From this tutorial:

cap.read() returns a bool (True/False). If the frame is read correctly, it will be True

If it is False you have several alternatives: continue the while loop, sleep for some time, terminate the program, release the video capture and create it again, etc. You can also combine them.

Example to release the video capture and create it again:

In the end, to exchange the driver / db connector worked for me:

1. Remove the mysqlclient from the dependencies

2. Add mysql-connector-python~=8.0 to the dependencies (insert into requirements.txt)

3. Adapt your DATABASES config like this in the settings.py file

I have found that I can install a version of python that reticulate is happy to work with, using reticulate itself. Ahead of rendering the Rmarkdown document, I can use:

Don't know anything about Kafka but what your screenshoys shows is in Ruby a Hash (map) although only the keys are visible on the image. In Ruby, if the name of the Hash is event (I'm guessing here) then you can get to the value of the x-vcap-request-id key like this event["x-vcap-request-id"]

I use a string as key because your screeenshot suggests it is but in Ruby keys are most of the time Symbols (a kind of unique fixed string) so it could also be event[:x-vcap-request-id]