Re: [google-appengine] Prerelease SDK 1.4.0 is out!
Hello ikai, Thanks and congrats for the great release. Will there be an option for source code download control in app.yaml. according to the mail thread in pre-release of 1.3.8 we thought this will be implemented, and that would be very helpful. the feature announced now will be a very good add-on but, by default if the config is to be on app.yaml. Will there be any option for the creator of the app to get any versions source code. We have some use cases relying on this option. so please make a reply about this, accordingly we can streamline the development process at our team, Thanks On Fri, Nov 19, 2010 at 3:57 AM, Ikai Lan (Google) ikai.l+gro...@google.comikai.l%2bgro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. -
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
You'll be able to download code, but anyone that wants to turn it off will be able to go to their admin dashboard and push a one-way, irreversible button to disallow this feature. Please do not depend on this feature to do source control. -- Ikai Lan Developer Programs Engineer, Google App Engine Blogger: http://googleappengine.blogspot.com Reddit: http://www.reddit.com/r/appengine Twitter: http://twitter.com/app_engine On Tue, Nov 23, 2010 at 11:12 AM, Sandeep Koduri sandeep.kod...@gmail.comwrote: Hello ikai, Thanks and congrats for the great release. Will there be an option for source code download control in app.yaml. according to the mail thread in pre-release of 1.3.8 we thought this will be implemented, and that would be very helpful. the feature announced now will be a very good add-on but, by default if the config is to be on app.yaml. Will there be any option for the creator of the app to get any versions source code. We have some use cases relying on this option. so please make a reply about this, accordingly we can streamline the development process at our team, Thanks On Fri, Nov 19, 2010 at 3:57 AM, Ikai Lan (Google) ikai.l+gro...@google.com ikai.l%2bgro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
Wow wow! Thank you! On 18 November 2010 22:27, Ikai Lan (Google) ikai.l+gro...@google.comikai.l%2bgro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - Added a low-level AysncDatastoreService for making calls to the datastore asynchronously. - Added a getBodyAsBytes() method to QueueStateInfo.TaskStateInfo, this returns the body of the task state as a pure byte-string. - The whitelist has been updated to include all classes from javax.xml.soap. - Fixed an issue sending email to multiple recipients.
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
Very impressive! Thank you -- . ..: On Fri, Nov 19, 2010 at 10:30 AM, Andrius A andriu...@gmail.com wrote: Wow wow! Thank you! On 18 November 2010 22:27, Ikai Lan (Google) ikai.l+gro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - Added a low-level AysncDatastoreService for making calls to the datastore asynchronously. - Added a getBodyAsBytes() method to QueueStateInfo.TaskStateInfo, this returns the body of the task state as a pure byte-string. - The whitelist has been updated to include all classes from
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
On Thu, Nov 18, 2010 at 5:27 PM, Ikai Lan (Google) - The deadline for Task Queue and Cron requests has been raised to 10 minutes. This is really great for background processing and timed tasks which need greater than 1 minute resolution. Thank you! -- You received this message because you are subscribed to the Google Groups Google App Engine group. To post to this group, send email to google-appeng...@googlegroups.com. To unsubscribe from this group, send email to google-appengine+unsubscr...@googlegroups.com. For more options, visit this group at http://groups.google.com/group/google-appengine?hl=en.
[google-appengine] Prerelease SDK 1.4.0 is out!
Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - Added a low-level AysncDatastoreService for making calls to the datastore asynchronously. - Added a getBodyAsBytes() method to QueueStateInfo.TaskStateInfo, this returns the body of the task state as a pure byte-string. - The whitelist has been updated to include all classes from javax.xml.soap. - Fixed an issue sending email to multiple recipients. http://code.google.com/p/googleappengine/issues/detail?id=1623 As usual, we value your feedback, so don't hesitate to evaluate these SDKs and let us know. Be mindful that the server-side components have not been deployed yet, so uploaded code
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
Huge release. Looking forward to it going live. Nice work App Engine Team. Robert On Thu, Nov 18, 2010 at 17:27, Ikai Lan (Google) ikai.l+gro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - Added a low-level AysncDatastoreService for making calls to the datastore asynchronously. - Added a getBodyAsBytes() method to QueueStateInfo.TaskStateInfo, this returns the body of the task state as a pure byte-string. - The whitelist has been updated to include all classes from javax.xml.soap. - Fixed an issue sending email to
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
- The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. good catch -- You received this message because you are subscribed to the Google Groups Google App Engine group. To post to this group, send email to google-appeng...@googlegroups.com. To unsubscribe from this group, send email to google-appengine+unsubscr...@googlegroups.com. For more options, visit this group at http://groups.google.com/group/google-appengine?hl=en.
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
In Python, how do we use: - Channel API - Metadata Queries On Thu, Nov 18, 2010 at 5:40 PM, Robert Kluin robert.kl...@gmail.comwrote: Huge release. Looking forward to it going live. Nice work App Engine Team. Robert On Thu, Nov 18, 2010 at 17:27, Ikai Lan (Google) ikai.l+gro...@google.com ikai.l%2bgro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - Added a low-level AysncDatastoreService for making calls to
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
what's the cost of the always on feature? I can't seem to find it anywhere. Thanks, On Thu, Nov 18, 2010 at 5:27 PM, Ikai Lan (Google) ikai.l+gro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - Added a low-level AysncDatastoreService for making calls to the datastore asynchronously. - Added a getBodyAsBytes() method to QueueStateInfo.TaskStateInfo, this returns the body of the task state as a pure byte-string. - The whitelist has been updated to include all classes from javax.xml.soap. - Fixed an issue sending email to
Re: [google-appengine] Prerelease SDK 1.4.0 is out!
Or is there a prerelease location for the documentation? On Thu, Nov 18, 2010 at 5:45 PM, Ross M Karchner rosskarch...@gmail.comwrote: In Python, how do we use: - Channel API - Metadata Queries On Thu, Nov 18, 2010 at 5:40 PM, Robert Kluin robert.kl...@gmail.comwrote: Huge release. Looking forward to it going live. Nice work App Engine Team. Robert On Thu, Nov 18, 2010 at 17:27, Ikai Lan (Google) ikai.l+gro...@google.com ikai.l%2bgro...@google.com wrote: Hey everyone, I just wanted to let everyone know that prerelease SDK 1.4.0 is out! Get it from the Google Code project: http://code.google.com/p/googleappengine/downloads/list We're still working on the docs and will have them ready for the final release, so if there are any questions about how to use the new features, feel free to ask on this thread and I'll do my best to clarify them. The release notes are below. This is an EXCITING release: Python - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's app.yaml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry_parameters in their queue.yaml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URLFetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance latency in the Admin Console is now a weighted average over QPS per instance. - The developer who uploaded an app version can download that version's code using the appcfg.py download_app command. This feature can be disabled on a per application basis in the admin console, under the 'Permissions' tab. Once disabled, code download for the application CANNOT be re-enabled. - Fixed an issue where custom Admin Console pages did not work for Google Apps for your Domain users. - Allow Django initialization to be moved to appengine_config.py to avoid Django version conflicts when mixing webapp.template with pure Django. http://code.google.com/p/googleappengine/issues/detail?id=1758 - Fixed an issue in the dev_appserver where get_serving_url did not work for transparent, cropped PNGs: http://code.google.com/p/googleappengine/issues/detail?id=3887 - Fixed an issue with the DatastoreFileStub. http://code.google.com/p/googleappengine/issues/detail?id=3895 Java - - The Always On feature allows applications to pay and keep 3 instances of their application always running, which can significantly reduce application latency. - Developers can now enable Warmup Requests. By specifying a handler in an app's appengine-web.xml, App Engine will attempt to to send a Warmup Request to initialize new instances before a user interacts with it. This can reduce the latency an end-user sees for initializing your application. - The Channel API is now available for all users. - Task Queue has been officially released, and is no longer an experimental feature. The API import paths that use 'labs' have been deprecated. Task queue storage will count towards an application's overall storage quota, and will thus be charged for. - The deadline for Task Queue and Cron requests has been raised to 10 minutes. Datastore and API deadlines within those requests remain unchanged. - For the Task Queue, developers can specify task retry-parameters in their queue.xml. - Metadata Queries on the datastore for datastore kinds, namespaces, and entity properties are available. - URL Fetch allowed response size has been increased, up to 32 MB. Request size is still limited to 1 MB. - The Admin Console Blacklist page lists the top blacklist rejected visitors. - The automatic image thumbnailing service supports arbitrary crop sizes up to 1600px. - Overall average instance
