Google cloud to run Python program as localhost server using Cloud SDK shell
Error in google cloud shell:
ymal file codes
runtime:python37
api_version:1
threadsafe:false
handlers;
- url:/
script:test.py
test.py file code
print("hello world")
App Engine is used to host web apps.
I encourage you to have a look at Google's quickstart for App Engine and deploying a "Hello World!" app.
Your Python print("hello world") while valid Python is not a web server and won't work as-is on App Engine.
Google's documentation is comprehensive and should help you get to a running app.
Please don't include images in Stack overflow questions because these have poor accessibility.
In addition to the comments from DazWilkin,
You are using dev_appserver.py which is a development server that simulates Google App Engine (GAE) in Production. Google now discourages using that, especially for the newer runtimes like Python3. Instead Google encourages you to ..run your application in your local environment with the development tools that you usually use...
Another possible way of learning to use GAE is to look at/tinker with the code of an App which runs on GAE. For example, you can use our App, NoCommandLine, which has a hello world App in different languages including Python
a) Follow all the steps documented by Google here to install or update the Google Cloud App Engine SDK. You need to follow all the steps so that all the files are installed/copied and the necessary shortcuts created.
b) Download and install the NoCommandLine App
c) Open the App, then go to File > New Application, give your app a name (Application ID), select Python 3 under Runtime and click the 'Create' button.
d) A new application will be created. Select the App, click the 'run' icon. It will open your default browser and display 'Hello World'.
e) You can now navigate to the directory for the App and open the different files to see the structure and code and you can play around with the code
Note that to deploy your App to production i.e GAE Production, you first need to create a Project with the same name as your App running on local host and you need to provide a credit card (Google will not charge your card but you must provide it)
I want to create desktop application compatible with other OS.For that I'm using electron with angular.Because both are frame work whether it will effect performance or loading time, and also whether deploying easy,can we use all the features of angular when we use with electron like routing..?
Electron uses Chromium and NodeJS which is the reason why it is compatible with other OSs. You can talk with the NodeJS process from your angular-app which opens up some possibilities. For example opening native file-dialogs to let the user choose files. Electron also already abstracts some platform specific operations like getting the user home to save some configuration files for example.
You can use routing just like in any Angular app and I think you can use most features like you would normally but dont take me for granted on this one.
I would not say it affects your loading time to combine those too. During development you have to build your angular app before electron can start up and use those files but in production Angular is already ready to be loaded so they dont hinder each other.
I am absolutly new in WSO2 EI and I have the following doubt.
I am following this official tutorial to study the creation of a business process BPMN process):
https://docs.wso2.com/display/EI600/Quick+Start+Guide
If you go in this tutorial the second tab is refered to the Business Process Management tutorial, then I continue following the business process BPMN process street.
I followed all the tutorial and I think that I have understand the key concept of this example but I have some doubts about how to run this example.
At the end of the tutorial it does:
To create the Business Archive File (.bar), do the following.
On the Explorer, found in the upper left of your screen, navigate to Package Explorer.
Right click on the package and select “Create deployment artifacts”.
Navigate to the location of the source. You will find the .bar file inside the deployment folder.
So now I have my /HelloWorld/deployment/OrderApproval.bar file created.
But now what have I to do with this file?
I also have download the EI Server from here: /HelloWorld/deployment/OrderApproval.bar
Then I have configured it in my Eclipse Developer Studio EI setting it as a WSO2 server.
So my doubts are:
What exactly represent this OrderApproval.bar file? Is it a file representing a WSO2 EI executable project or what?
From what I have understand the previous example represents a work flow representing a BPMN process that implements a flow with some rules without that I need to write Java code (correct me if I am doing wrong assertion). But is it something executable or something that have to be integrated into some other application?
If it is an executable project what have I to do to run it and interact with it?
BPMN is process definition that can be run on BPS server. BPS server is part of WSO2 EI solution. You have to run it from [EI_HOME]/wso2/business-process/bin
On Linux/Mac OS: sh wso2server.sh
On Windows: wso2server.bat --run
Then, when it works correctly, open https : // [serverIP]:[port]/carbon/ and log into the EI-Business Process management console.
Next navigate to Home -> Manage -> Processes ->Add -> BPMN and upload your OrderApproval.bar file.
After uploading file, log into the BPMN-explorer at https : // [serverIP]:[port]/bpmn-explorer. On the "proecesses" tab you should see your process which can be run by action->start.
Try studie this example: https://docs.wso2.com/display/EI600/Creating+a+BPMN+Process
Is there a way to easily distribute an electron.atom.io app as a static site?
I don't need all the functionality, I just want to allow the client to view the latest updates.
-- edit --
Perhaps a better way to ask the question is; "How do I build a web app that can be hosted online and run on electron with minimum rewriting" - similar to the Slack app that works the same way on web or electron app.
As long as your main use of Electron is to create a 'native browser wrapper' for a web-app this is entirely possible.
You will have to implement a check if your application is running inside a browser or inside Electron and wrap your electron specific code in it:
if (window && window.process && process.versions['electron']) {
const {BrowserWindow} = require('electron').remote
}
You'll probably have to step through your application and disable Electron specific functionality at multiple places.
You have other options to do a long distance demo of an Electron app
Electron is basically a shell to run node.js apps on the desktop. This means if you want to move it to the web, you have to give up all the Electron APIs that access the local system and you're left with a basic node.js app, which is most likely not desirable.
To demo your desktop app to an off-site client, you can either make a presentation with screenshots detailing the current user flow, or compile a sandboxed demo version of your app and send it over to them.
Screen presentation
This is your quickest and easiest solution if your client just wants to be kept in the loop and see some eye candy. You can just record how the app works with some example data, add some written or audio explanation to it, and let them enjoy the smooth ride.
Build a demo
If your client wants to actually have a hands-on demo with the app, you need to have some form of basic code distribution. The cleanest way to do this would be to tie up all loose ends in your current app flows, block all unfinished roads in it and compile it for whatever platform your client requested the demo for.
Take a look at the electron-packager and electron-builder docs to get an idea how to build an .exe, .dmg or whatever file from your Electron app, then send that file to them with some basic instructions.
I need to update my application from a central server.
The application checks always if it is a correct version, against the server installation.
So when it is not, I need it to update itself.
So how can I copy the EXE if it is running? What solution do I have?
I rename the current running exe to MyTempExe.exe, copy the new exe to the correct location (request elevated privileges if necessary) and then run a separate app to restart the main app. On start up I check for MyTempExe.exe delete it if it's there.
The reason I use a separate app for the restart is I don't have a set time frame for the app to close down and need to wait for it to finish whatever it's doing, on shutdown it writes information to disk about its current state that the updated app will use to resume where the old one left off.
I don't know if it's the best solution but it's the one I use.
As you can see by all the answers there is no set way to do this, so I thought I would add the way we have successfully done this.
We never run an application directly from the network.
We run the application from the local machine and have it copy from the network on startup.
We do this using an application launcher. It downloads an XML file that contains CRC and Version Resource Values for the application files. The XML File is created during the deployment process, in a FinalBuilder Script.
The application then compares the XML File to local content, and copies down needed files. Finally we then launch the application in question. This has worked well for deploying an application that serves around 300 local users. Recently we switch from a file copy to an HTTP download as we found problems with remote user disconnecting drives.
We still still build installations (With Innosetup) to get the basic required files deployed.
Package your app with an installer such as Inno. Download and execute the installer. Have the installer search for and kill your app, or instruct the user to close it. The setup will replace your .exe, and if the app can't be killed or the user is non-cooperative, it'll issue a re-start notice.
Download new EXE to TEMP
Create Batch from EXE, content:
taskkill /PID %process id of running EXE%
copy %new EXE% %running EXE%
%EXE%
all values in %...% are placeholders
execute batch from the running EXE
delete batch
I use TMS TWebUpdate myself, for software updates. The advantage is that there a bunch of extra actions you can put into the script, if you need anything other than plain EXE updates.
I have two components at work the application executable itself and a web-service (SOAP) which provides version details and file downloads.
The application calls a method on the SOAP service to ask for the number of files in the project (project is identified by using the application.exename usually).
The soap service gets its info from an INI file, which has entries like:
[ProjectName]
NumberOfFiles=2
File1=myapp.exe;1.0.0.1
File2=mydll.dll;1.0.0.2
You just update this file at the same time as uploading your new files.
The process of updating the application this:
Get number of files available on the web service
For each file, the application asks for the name and version number from the SOAP server.
The application compares this information to its own version info and decides if the file needs updating, building a local list of files that need updating.
For each file that needs updating the application downloads the file to filename.ext.new
Finally, the application renames all filename.ext to filename.ext.old and renames filename.ext.new to filename.ext and then restarts itself. (No real need for an external app to restart your own program).
Note 1, that you may have to ask for elevation to replace files, depending on where you install your files.
Note 2: be kind to your users, think carefully before you force updates on users.
Note 3: You cannot delete a running exe, but you can rename it and then restart the new version.
Edit===
For some reference data files which cannot contain version information resources, you can have entires like File99=MyDataFile;1.1.2011 the 3 elements to the version number indicates to the client that it should check against the file date/stamp.
You could have a separate update executable whose task is to check the server version, download an updated executable if necessary, and then run the local executable.
Or you could have one executable running in two different modes: 1. on startup, check for an update, if there is one, download the executable to a download directory, run it and quit.
2. The new executable would check if it's running from the installation directory, if not, it would copy itself there, overwriting the old version, start the copy from there, and quit.
My way is the other way round: If a new version is online, promt the user to update. If he want's to (or is forced to...) I end the app and start a new exe (updater). this updater loads the update and replaces the old exe (not running). then it starts the new exe. ready. (You can of course replace other files too.) BUT: Using an Installer like InnoSetup gives you more possibilities and doesn't mix up with the regular uninstaller, so it is really better...
You can do this without running another application. Push the updates to the client from the server while running, storing in a temporary directory on the client. When you want to upgrade move all your running files to another temporary directory, move the new files into the original application directory, and just restart the application using the standard executable name on shutdown.
I upgrade client applications running on unattended machines automatically this way.