Debugging Techniques¶
Be it when initially setting up mod_wsgi for the first time, or later during development or use of your WSGI application, you are bound to get some sort of unexpected Python error. By default all you are usually going to see as evidence of this is a HTTP 500 “Internal Server Error” being displayed in the browser window and little else.
The purpose of this document is to explain where to go look for more details on what caused the error, describe techniques one can use to have your WSGI application generate more useful debug information, as well as mechanisms that can be employed to interactively debug your application.
Note that although this document is intended to deal with techniques which can be used when using mod_wsgi, many of the techniques are also directly transferable or adaptable to other web hosting mechanisms for WSGI applications.
Apache Error Log Files¶
When using mod_wsgi, unless you or the web framework you are using takes specific action to catch exceptions and present the details in an alternate manner, the only place that details of uncaught exceptions will be recorded is in the Apache error log files. The Apache error log files are therefore your prime source of information when things go wrong.
Do note though that log messages generated by mod_wsgi are logged with various severity levels and which ones will be output to the Apache error log files will depend on how Apache has been configured. The standard configuration for Apache has the !LogLevel directive being set to ‘warn’. With this setting any important error messages will be output, but informational messages generated by mod_wsgi which can assist in working out what it is doing are not. Thus, if new to mod_wsgi or trying to debug a problem, it is worthwhile setting the Apache configuration to use ‘info’ log level instead:
LogLevel info
If your Apache web server is only providing services for one host, it is likely that you will only have one error log file. If however the Apache web server is configured for multiple virtual hosts, then it is possible that there will be multiple error log files, one corresponding to the main server host and an additional error log file for each virtual host. Such a virtual host specific error log if one is being used, would have been configured through the placing of the Apache CustomLog directive within the context of the VirtualHost container.
Although your WSGI application may be hosted within a particular virtual host and that virtual host has its own error log file, some error and informational messages will still go to the main server host error log file. Thus you may still need to consult both error log files when using virtual hosts.
Messages of note that will end up in the main server host error log file include notifications in regard to initialisation of Python and the creation and destruction of Python sub interpreters, plus any errors which occur when doing this.
Messages of note that would end up in the virtual host error log file, if it exists, include details of uncaught Python exceptions which occur when the WSGI application script is being loaded, or when the WSGI application callable object is being executed.
Messages that are logged by a WSGI application via the ‘wsgi.errors’ object passed through to the application in the WSGI environment are also logged. These will go to the virtual host error log file if it exists, or the main error log file if the virtual host is not setup with its own error log file. Thus, if you want to add debugging messages to your WSGI application code, you can use ‘wsgi.errors’ in conjunction with the ‘print’ statement as shown below:
def application(environ, start_response):
status = '200 OK'
output = b'Hello World!'
print >> environ['wsgi.errors'], "application debug #1"
response_headers = [('Content-type', 'text/plain'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
print >> environ['wsgi.errors'], "application debug #2"
return [output]
If ‘wsgi.errors’ is not available to the code which needs to output log messages, then it should explicitly direct output from the ‘print’ statement to ‘sys.stderr’:
import sys
def function():
print >> sys.stderr, "application debug #3"
...
If sys.stderr
or sys.stdout
is used directly then
these messages will end up in the main server host error log file and not
that for the virtual host unless the WSGI application is running in a
daemon process specifically associated with a virtual host.
Do be aware though that writing to sys.stdout
is by default
restricted in versions of mod_wsgi prior to 3.0 and will result in an
exception occurring of the form:
IOError: sys.stdout access restricted by mod_wsgi
This is because portable WSGI applications should not write to
sys.stdout
or use the ‘print’ statement without specifying an
alternate file object besides sys.stdout
as the target. This
restriction can be disabled for the whole server using the
WSGIRestrictStdout directive, or by mapping sys.stdout
to
sys.stderr
at global scope within in the WSGI application script
file:
import sys
sys.stdout = sys.stderr
In general, a WSGI application should always endeavour to only log messages via the ‘wsgi.errors’ object that is passed through to a WSGI application in the WSGI environment. This is because this is the only way of logging messages for which there is some guarantee that they will end up in a log file that you might have access to if using a shared server.
An application shouldn’t however cache ‘wsgi.errors’ and try to use it outside of the context of a request. If this is done an exception will be raised indicating that the request has expired and the error log object is now invalid.
That messages output via sys.stderr
and sys.stdout
end up in
the Apache error logs at all is provided as a convenience but there is no
requirement in the WSGI specification that they are valid means of a WSGI
application logging messages.
Displaying Request Environment¶
When a WSGI application is invoked, the request headers are passed as CGI variables in the WSGI request environment. The dictionary used for this also holds information about the WSGI execution environment and mod_wsgi. This includes mod_wsgi specific variables indicating the name of the process and application groups within which the WSGI application is executing.
Knowing the values of the process and application group variables can be important when needing to validate that your Apache configuration is doing what you intended as far as ensuring your WSGI application is running in daemon mode or otherwise.
A simple way of validating such details or getting access to any of the other WSGI request environment variables is to substitute your existing WSGI application with one which echos back the details to your browser. Such a task can be achieved with the following test application. The application could be extended as necessary to display other information as well, with process ID, user ID and group ID being shown as examples:
import cStringIO
import os
def application(environ, start_response):
headers = []
headers.append(('Content-Type', 'text/plain'))
write = start_response('200 OK', headers)
input = environ['wsgi.input']
output = cStringIO.StringIO()
print >> output, "PID: %s" % os.getpid()
print >> output, "UID: %s" % os.getuid()
print >> output, "GID: %s" % os.getgid()
print >> output
keys = environ.keys()
keys.sort()
for key in keys:
print >> output, '%s: %s' % (key, repr(environ[key]))
print >> output
output.write(input.read(int(environ.get('CONTENT_LENGTH', '0'))))
return [output.getvalue()]
For the case of the process group as recorded by the ‘mod_wsgi.process_group’ variable in the WSGI request environment, if the value is an empty string then the WSGI application is running in embedded mode. For any other value it will be running in daemon mode with the process group named by the variables value.
Note that by default WSGI applications run in embedded mode, which means within the Apache server child processes which accept the original requests. Daemon mode processes would only be used through appropriate use of the WSGIDaemonProcess and WSGIProcessGroup directives to delegate the WSGI application to a named daemon process group.
For the case of the application group as recorded by the ‘mod_wsgi.application_group’ variable in the WSGI request environment, if the value is an empty string then the WSGI application is running in the main Python interpreter. That is, the very first interpreter created when Python was initialised. For any other value it indicates it is running in the named Python sub interpreter.
Note that by default WSGI applications would always run in a sub interpreter rather than the main interpreter. The name of this sub interpreter would be automatically constructed from the name of the server or virtual host, the URL mount point of the WSGI application and the number of the listener port when it is other than ports 80 or 443.
To delegate a WSGI application to run in main Python interpreter, the WSGIApplicationGroup directive would need to have been used with the value ‘%{GLOBAL}’. Although the value is ‘%{GLOBAL}’, this translates to the empty string seen for the value of ‘mod_wsgi.application_group’ within the WSGI request environment.
The WSGIApplicationGroup directive could also be used to designate a specific named sub interpreter rather than that selected automatically.
For newcomers this can all be a bit confusing, which is where the test application comes in as you can use it to validate where your WSGI application is running is where you intended it to run.
The set of WSGI request environment variables will also show the WSGI variables indicating whether process is multithreaded and whether the process group is multiprocess or not. For a more complete explanation of what that means see documentation of Processes And Threading.
Tracking Request and Response¶
Although one can use above test application to display the request environment, it is replacing your original WSGI application. Rather than replace your existing application you can use a WSGI middleware wrapper application which logs the details to the Apache error log instead:
# Original WSGI application.
def application(environ, start_response):
...
# Logging WSGI middleware.
import pprint
class LoggingMiddleware:
def __init__(self, application):
self.__application = application
def __call__(self, environ, start_response):
errors = environ['wsgi.errors']
pprint.pprint(('REQUEST', environ), stream=errors)
def _start_response(status, headers, *args):
pprint.pprint(('RESPONSE', status, headers), stream=errors)
return start_response(status, headers, *args)
return self.__application(environ, _start_response)
application = LoggingMiddleware(application)
The output from the middleware would end up in the Apache error log for the virtual host, or if no virtual host specific error log file, in the main Apache error log file.
For more complicated problems it may also be necessary to track both the request and response content as well. A more complicated middleware which can log these as well as header information to the file system is as follows:
# Original WSGI application.
def application(environ, start_response):
...
# Logging WSGI middleware.
import threading
import pprint
import time
import os
class LoggingInstance:
def __init__(self, start_response, oheaders, ocontent):
self.__start_response = start_response
self.__oheaders = oheaders
self.__ocontent = ocontent
def __call__(self, status, headers, *args):
pprint.pprint((status, headers)+args), stream=self.__oheaders)
self.__oheaders.close()
self.__write = self.__start_response(status, headers, *args)
return self.write
def __iter__(self):
return self
def write(self, data):
self.__ocontent.write(data)
self.__ocontent.flush()
return self.__write(data)
def next(self):
data = self.__iterable.next()
self.__ocontent.write(data)
self.__ocontent.flush()
return data
def close(self):
if hasattr(self.__iterable, 'close'):
self.__iterable.close()
self.__ocontent.close()
def link(self, iterable):
self.__iterable = iter(iterable)
class LoggingMiddleware:
def __init__(self, application, savedir):
self.__application = application
self.__savedir = savedir
self.__lock = threading.Lock()
self.__pid = os.getpid()
self.__count = 0
def __call__(self, environ, start_response):
self.__lock.acquire()
self.__count += 1
count = self.__count
self.__lock.release()
key = "%s-%s-%s" % (time.time(), self.__pid, count)
iheaders = os.path.join(self.__savedir, key + ".iheaders")
iheaders_fp = file(iheaders, 'w')
icontent = os.path.join(self.__savedir, key + ".icontent")
icontent_fp = file(icontent, 'w+b')
oheaders = os.path.join(self.__savedir, key + ".oheaders")
oheaders_fp = file(oheaders, 'w')
ocontent = os.path.join(self.__savedir, key + ".ocontent")
ocontent_fp = file(ocontent, 'w+b')
errors = environ['wsgi.errors']
pprint.pprint(environ, stream=iheaders_fp)
iheaders_fp.close()
length = int(environ.get('CONTENT_LENGTH', '0'))
input = environ['wsgi.input']
while length != 0:
data = input.read(min(4096, length))
if data:
icontent_fp.write(data)
length -= len(data)
else:
length = 0
icontent_fp.flush()
icontent_fp.seek(0, os.SEEK_SET)
environ['wsgi.input'] = icontent_fp
iterable = LoggingInstance(start_response, oheaders_fp, ocontent_fp)
iterable.link(self.__application(environ, iterable))
return iterable
application = LoggingMiddleware(application, '/tmp/wsgi')
For this middleware, the second argument to the constructor should be a preexisting directory. For each request four files will be saved. These correspond to input headers, input content, response status and headers, and request content.
Poorly Performing Code¶
The WSGI specification allows any iterable object to be returned as the response, so long as the iterable yields string values. That this is the case means that one can too easily return an object which satisfies this requirement but has some sort of performance related issue.
The worst case of this is where instead of returning a list containing strings, a single string is returned. The problem with a string is that when it is iterated over, a single character of the string is yielded each time. In other words, a single character is written back to the client on each loop, with a flush occurring in between to ensure that the character has actually been written and isn’t just being buffered.
Although for small strings a performance impact may not be noticed, if returning large strings the affect on request throughput could be quite significant.
Another case which can cause problems is to return a file like object. For iteration over a file like object, typically what can occur is that a single line within the file is returned each time. If the file is a line oriented text file where each line is a of a reasonable length, this may be okay, but if the file is a binary file there may not actually be line breaks within the file.
For the case where file contains many short lines, throughput would be affected much like in the case where a string is returned. For the case where the file is just binary data, the result can be that the complete file may be read in on the first loop. If the file is large, this could cause a large transient spike in memory usage. Once that memory is allocated, it will then be retained by the process, albeit that it may be reused by the process at a later point.
Because of the performance impacts in terms of throughput and memory usage, both these cases should be avoided. For the case of returning a string, it should be returned with a single element list. For the case of a file like object, the ‘wsgi.file_wrapper’ extension should be used, or a wrapper which suitably breaks the response into chunks.
In order to identify where code may be inadvertently returning such iterable types, the following code can be used:
import types
import cStringIO
import socket
import StringIO
BAD_ITERABLES = [
cStringIO.InputType,
socket.SocketType,
StringIO.StringIO,
types.FileType,
types.StringType,
]
class ValidatingMiddleware:
def __init__(self, application):
self.__application = application
def __call__(self, environ, start_response):
errors = environ['wsgi.errors']
result = self.__application(environ, start_response)
value = type(result)
if value == types.InstanceType:
value = result.__class__
if value in BAD_ITERABLES:
print >> errors, 'BAD ITERABLE RETURNED: ',
print >> errors, 'URL=%s ' % environ['REQUEST_URI'],
print >> errors, 'TYPE=%s' % value
return result
def application(environ, start_response):
...
application = ValidatingMiddleware(application)
Error Catching Middleware¶
Because mod_wsgi only logs details of uncaught exceptions to the Apache error log and returns a generic HTTP 500 “Internal Server Error” response, if you want the details of any exception to be displayed in the error page and be visible from the browser, you will need to use a WSGI error catching middleware component.
One example of WSGI error catching middleware is the ErrorMiddleware class from Paste.
This class can be configured not only to catch exceptions and present the details to the browser in an error page, it can also be configured to send the details of any errors in email to a designated recipient, or log the details to an alternate log file.
Being able to have error details sent by email would be useful in a production environment or where your application is running on a web hosting environment and the Apache error logs would not necessarily be closely monitored on a day to day basis. Enabling of that particular feature though should possibly only be done when you have some confidence in the application else you might end up getting inundated with emails.
To use the error catching middleware from Paste you simply need to wrap your existing application with it such that it then becomes the top level application entry point:
def application(environ, start_response):
status = '200 OK'
output = b'Hello World!\n'
response_headers = [('Content-type', 'text/plain'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
return [output]
from paste.exceptions.errormiddleware import ErrorMiddleware
application = ErrorMiddleware(application, debug=True)
In addition to displaying information about the Python exception that has occurred and the stack traceback, this middleware component will also output information about the WSGI environment such that you can see what was being passed to the WSGI application. This can be useful if the cause of any problem was unexpected values passed in the headers of the HTTP request.
Note that error catching middleware is of absolutely no use for trying to capture and display in the browser any errors that occur at global scope within the WSGI application script when it is being imported. Details of any such errors occurring at this point will only be captured in the Apache error log files. As much as possible you should avoid performing complicated tasks when the WSGI application script file is being imported, instead you should only trigger such actions the first time a request is received. By doing this you will be able to capture errors in such initialisation code with the error catching middleware.
Also note that the debug mode whereby details are displayed in the browser should only be used during development and not in a production system. This is because details which are displayed may be of use to anyone who may wish to compromise your site.
Python Interactive Debugger¶
Python debuggers such as implemented by the ‘pdb’ module can sometimes be useful in debugging Python applications, especially where there is a need to single step through code and analyse application state at each point. Use of such debuggers in web applications can be a bit more tricky than normal applications though and especially so with mod_wsgi.
The problem with mod_wsgi is that the Apache web server can create multiple child processes to respond to requests. Partly because of this, but also just to prevent problems in general, Apache closes off standard input at startup. Thus there is no actual way to interact with the Python debugger module if it were used.
To get around this requires having complete control of the Apache web server that you are using to host your WSGI application. In particular, it will be necessary to shutdown the web server and then startup the ‘httpd’ process explicitly in single process debug mode, avoiding the ‘apachectl’ management application altogether:
$ apachectl stop
$ httpd -X
If Apache is normally started as the ‘root’ user, this also will need to be run as the ‘root’ user otherwise the Apache web server will not have the required permissions to write to its log directories etc.
The result of starting the ‘httpd’ process in this way will be that the Apache web server will run everything in one process rather than using multiple processes. Further, it will not close off standard input thus allowing the Python debugger to be used.
Do note though that one cannot be using the ability of mod_wsgi to run your application in a daemon process when doing this. The WSGI application must be running within the main Apache process.
To trigger the Python debugger for any call within your code, the following customised wrapper for the ‘Pdb’ class should be used:
class Debugger:
def __init__(self, object):
self.__object = object
def __call__(self, *args, **kwargs):
import pdb, sys
debugger = pdb.Pdb()
debugger.use_rawinput = 0
debugger.reset()
sys.settrace(debugger.trace_dispatch)
try:
return self.__object(*args, **kwargs)
finally:
debugger.quitting = 1
sys.settrace(None)
This might for example be used to wrap the actual WSGI application callable object:
def application(environ, start_response):
status = '200 OK'
output = b'Hello World!\n'
response_headers = [('Content-type', 'text/plain'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
return [output]
application = Debugger(application)
When a request is now received, the Python debugger will be triggered and you can interactively debug your application from the window you ran the ‘httpd’ process. For example:
> /usr/local/wsgi/scripts/hello.py(21)application()
-> status = '200 OK'
(Pdb) list
16 finally:
17 debugger.quitting = 1
18 sys.settrace(None)
19
20 def application(environ, start_response):
21 -> status = '200 OK'
22 output = b'Hello World!\n'
23
24 response_headers = [('Content-type', 'text/plain'),
25 ('Content-Length', str(len(output)))]
26 start_response(status, response_headers)
(Pdb) print start_response
<built-in method start_response of mod_wsgi.Adapter object at 0x1160180>
cont
When wishing to allow the request to complete, issue the ‘cont’ command. If wishing to cause the request to abort, issue the ‘quit’ command. This will result in a ‘BdbQuit’ exception being raised and would result in a HTTP 500 “Internal Server Error” response being returned to the client. To kill off the whole ‘httpd’ process, after having issued ‘cont’ or ‘quit’ to exit the debugger, interrupt the process using ‘CTRL-C’.
To see what commands the Python debugger accepts, issue the ‘help’ command and also consult the documentation for the ‘pdb’ module on the Python web site.
Note that the Python debugger expects to be able to write to
sys.stdout
to display information to the terminal. Thus if using
using a Python web framework which replaces sys.stdout
such as
web.py, you will not be able to use the Python debugger.
Browser Based Debugger¶
In order to use the Python debugger modules you need to have direct access to the host and the Apache web server that is running your WSGI application. If your only access to the system is via your web browser this makes the use of the full Python debugger impractical.
An alternative to the Python debugger modules which is available is an extension of the WSGI error catching middleware previously described. This is the EvalException class from Paste. It embodies the error catching attributes of the ErrorMiddleware class, but also allows some measure of interactive debugging and introspection through the web browser.
As with any WSGI middleware component, to use the class entails creating a wrapper around the application you wish to debug:
def application(environ, start_response):
status = '200 OK'
output = b'Hello World!\n'
response_headers = [('Content-type', 'text/plain'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
return [output]
from paste.evalexception.middleware import EvalException
application = EvalException(application)
Like ErrorMiddleware when an unexpected exception occurs a web page is presented which shows the location of the error along with the contents of the WSGI application environment. Where EvalException is different however is that it is possible to inspect the local variables residing within each stack frame down to where the error occurred. Further, it is possible to enter Python code which can be evaluated within the context of the selected stack frame in order to access data or call functions or methods of objects.
In order for this to all work requires that subsequent requests back to the WSGI application always end up with the same process where the error originally occurred. With mod_wsgi this does however present a bit of a problem as Apache can create and use multiple child processes to handle requests.
Because of this requirement, if you want to be able to use this browser based interactive debugger, if running your application in embedded mode of mod_wsgi, you will need to configure Apache such that it only starts up one child process to handle requests and that it never creates any additional processes. The Apache configuration directives required to achieve this are as follows:
StartServers 1
ServerLimit 1
The directives must be placed at global scope within the main Apache configuration files and will affect the whole Apache web server.
If you are using the worker MPM on a UNIX system, restricting Apache to just a single process may not be an issue, at least during development. If however you are using the prefork MPM on a UNIX system, you may see issues if you are using an AJAX intensive page that relies on being able to execute parallel requests, as only one request at a time will be able to be handled by the Apache web server.
If using Apache 2.X on a UNIX system, a better approach is to use daemon mode of mod_wsgi and delegate your application to run in a single daemon process. This process may be single or multithreaded as per any threading requirements of your application.
Which ever configuration is used, if the browser based interactive debugger is used it should only be used on a development system and should never be deployed on a production system or in a web hosting environment. This is because the debugger will allow one to execute arbitrary Python code within the context of your application from a remote client.
Debugging Crashes With GDB¶
In cases where Apache itself crashes for no apparent reason, the above techniques are not always particularly useful. This is especially the case where the crash occurs in non Python code outside of your WSGI application.
The most common cause of Apache crashing, besides any still latent bugs that may exist in mod_wsgi, of which hopefully there aren’t any, are shared library version mismatches. Another major cause of crashes is third party C extension modules for Python which are not compatible with being used in a Python sub interpreter which isn’t the first interpreter created when Python is initialised, or modules which are not compatible with Python sub interpreters being destroyed and the module then being used in a new Python sub interpreter.
Examples of where shared library version mismatches are known to occur are between the version of the ‘expat’ library used by Apache and that embedded within the Python ‘pyexpat’ module. Another is between the version of the MySQL client libraries used by PHP and the Python MySQL module.
Both these can be a cause of crashes where the different components are compiled and linked against different versions of the shared library for the packages in question. It is vitally important that all packages making use of a shared library were compiled against and use the same version of a shared library.
Another problematic package is Subversion. In this case there can be conflicts between the version of Subversion libraries used by mod_dav_svn and the Python Subversion bindings. Certain versions of the Python Subversion modules also cause problems because they appear to be incompatible with use in a Python sub interpreter which isn’t the first interpreter created when Python is initialised.
In this latter issue, the sub interpreter problems can often be solved by
forcing the WSGI application using the Python Subversion modules to run in
the ‘%{GLOBAL}’ application group. This solution often also resolves issues
with SWIG generated bindings, especially where the -thread
option was
supplied to ‘swig’ when the bindings were generated.
Whatever the reason, in some cases the only way to determine why Apache or Python is crashing is to use a C code debugger such as ‘gdb’. Now although it is possible to attach ‘gdb’ to a running process, the preferred method for using ‘gdb’ in conjunction with Apache is to run Apache in single process debug mode from within ‘gdb’.
To do this it is necessary to first shutdown Apache. The ‘gdb’ debugger can then be started against the ‘httpd’ executable and then the process started up from inside of ‘gdb’:
$ /usr/local/apache/bin/apachectl stop
$ sudo gdb /usr/local/apache/bin/httpd
GNU gdb 6.1-20040303 (Apple version gdb-384) (Mon Mar 21 00:05:26 GMT 2005)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "powerpc-apple-darwin"...Reading symbols for shared
libraries ........ done
(gdb) run -X
Starting program: /usr/local/apache/bin/httpd -X
Reading symbols for shared libraries .+++ done
Reading symbols for shared libraries ..................... done
If Apache is normally started as the ‘root’ user, this also will need to be run as the ‘root’ user otherwise the Apache web server will not have the required permissions to write to its log directories etc.
If Apache was crashing on startup, you should immediately encounter the error, otherwise use your web browser to access the URL which is causing the crash to occur. You can then commence trying to debug why the crash is occurring.
Note that you should ensure that you have not assigned your WSGI application to run in a mod_wsgi daemon process using the WSGIDaemonProcess and WSGIProcessGroup directives. This is because the above procedure will only catch crashes which occur when the application is running in embedded mode. If it turns out that the application only crashes when run in mod_wsgi daemon mode, an alternate method of using ‘gdb’ will be required.
In this circumstance you should run Apache as normal, but ensure that you only create one mod_wsgi daemon process and have it use only a single thread:
WSGIDaemonProcess debug threads=1
WSGIProcessGroup debug
If not running the daemon process as a distinct user where you can tell which process it is, then you will also need to ensure that Apache !LogLevel directive has been set to ‘info’. This is to ensure that information about daemon processes created by mod_wsgi are logged to the Apache error log. This is necessary, as you will need to consult the Apache error logs to determine the process ID of the daemon process that has been created for that daemon process group:
mod_wsgi (pid=666): Starting process 'debug' with threads=1.
Knowing the process ID, you should then run ‘gdb’, telling it to attach directly to the daemon process:
$ sudo gdb /usr/local/apache/bin/httpd 666
GNU gdb 6.1-20040303 (Apple version gdb-384) (Mon Mar 21 00:05:26 GMT 2005)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "powerpc-apple-darwin"...Reading symbols for shared
libraries ........ done
/Users/grahamd/666: No such file or directory.
Attaching to program: `/usr/local/apache/bin/httpd', process 666.
Reading symbols for shared libraries .+++..................... done
0x900c7060 in sigwait ()
(gdb) cont
Continuing.
Once ‘gdb’ has been started and attached to the process, then initiate the request with the URL that causes the application to crash.
Attaching to the running daemon process can also be useful where a single request or the whole process is appearing to hang. In this case one can force a stack trace to be output for all running threads to try and determine what code is getting stuck. The appropriate gdb command in this instance is ‘thread apply all bt’:
sudo gdb /usr/local/apache-2.2/bin/httpd 666
GNU gdb 6.3.50-20050815 (Apple version gdb-477) (Sun Apr 30 20:06:22 GMT 2006)
Copyright 2004 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB. Type "show warranty" for details.
This GDB was configured as "powerpc-apple-darwin"...Reading symbols
for shared libraries ....... done
/Users/grahamd/666: No such file or directory.
Attaching to program: `/usr/local/apache/bin/httpd', process 666.
Reading symbols for shared libraries .+++..................... done
0x900c7060 in sigwait ()
(gdb) thread apply all bt
Thread 4 (process 666 thread 0xd03):
#0 0x9001f7ac in select ()
#1 0x004189b4 in apr_pollset_poll (pollset=0x1894650,
timeout=-1146117585187099488, num=0xf0182d98, descriptors=0xf0182d9c)
at poll/unix/select.c:363
#2 0x002a57f0 in wsgi_daemon_thread (thd=0x1889660, data=0x18895e8)
at mod_wsgi.c:6980
#3 0x9002bc28 in _pthread_body ()
Thread 3 (process 666 thread 0xc03):
#0 0x9001f7ac in select ()
#1 0x0041d224 in apr_sleep (t=1000000) at time/unix/time.c:246
#2 0x002a2b10 in wsgi_deadlock_thread (thd=0x0, data=0x2aee68) at
mod_wsgi.c:7119
#3 0x9002bc28 in _pthread_body ()
Thread 2 (process 666 thread 0xb03):
#0 0x9001f7ac in select ()
#1 0x0041d224 in apr_sleep (t=299970002) at time/unix/time.c:246
#2 0x002a2dec in wsgi_monitor_thread (thd=0x0, data=0x18890e8) at
mod_wsgi.c:7197
#3 0x9002bc28 in _pthread_body ()
Thread 1 (process 666 thread 0x203):
#0 0x900c7060 in sigwait ()
#1 0x0041ba9c in apr_signal_thread (signal_handler=0x2a29a0
<wsgi_check_signal>) at threadproc/unix/signals.c:383
#2 0x002a3728 in wsgi_start_process (p=0x1806418, daemon=0x18890e8)
at mod_wsgi.c:7311
#3 0x002a6a4c in wsgi_hook_init (pconf=0x1806418, ptemp=0x0,
plog=0xc8, s=0x18be8d4) at mod_wsgi.c:7716
#4 0x0000a5b0 in ap_run_post_config (pconf=0x1806418, plog=0x1844418,
ptemp=0x180e418, s=0x180da78) at config.c:91
#5 0x000033d4 in main (argc=3, argv=0xbffffa8c) at main.c:706
It is suggested when trying to debug such issues that the daemon process be made to run with only a single thread. This will reduce how many stack traces one needs to analyse.
If you are running with multiple processes within the daemon process group and all requests are hanging, you will need to get a snapshot of what is happening in all processes in the daemon process group. Because doing this by hand will be tedious, it is better to automate it.
To automate capturing the stack traces, first create a file called ‘gdb.cmds’ which contains the following:
set pagination 0
thread apply all bt
detach
quit
This can then be used in conjunction with ‘gdb’ to avoid needing to enter the commands manually. For example:
sudo gdb /usr/local/apache-2.2/bin/httpd -x gdb.cmds -p 666
To be able to automate this further and apply it to all processes in a daemon process group, then first off ensure that daemon processes are named in ‘ps’ output by using the ‘display-name’ option to WSGIDaemonProcess directive.
For example, to apply default naming strategy as implemented by mod_wsgi, use:
WSGIDaemonProcess xxx display-name=%{GLOBAL}
In the output of a BSD derived ‘ps’ command, this will now show the process as being named ‘(wsgi:xxx)’:
$ ps -cxo command,pid | grep wsgi
(wsgi:xxx) 666
Note that the name may be truncated as the resultant name can be no longer than what was the length of the original executable path for Apache. You may therefore like to name it explicitly:
WSGIDaemonProcess xxx display-name=(wsgi:xxx)
Having named the processes in the daemon process group, we can now parse the output of ‘ps’ to identify the process and apply the ‘gdb’ command script to each:
for pid in `ps -cxo command,pid | awk '{ if ($0 ~ /wsgi:xxx/ && $1 !~ /grep/) print $NF }'`; do sudo gdb -x gdb.cmds -p $pid; done
The actual name given to the daemon process group using the ‘display-name’ option should be replaced in this command line. That is, change ‘wsgi:xxx’ appropriately.
If you are having problems with process in daemon process groups hanging, you might consider implementing a monitoring system which automatically detects somehow when the processes are no longer responding to requests and automatically trigger this dump of the stack traces before restarting the daemon process group or Apache.
Extracting Python Stack Traces¶
Using gdb to get stack traces as described above only gives you information about what is happening at the C code level. This will not tell where in the actual Python code execution was at. Your only clue is going to be where a call out was being made to some distinct C function in a C extension module for Python.
One can get stack traces for Python code by using:
def _stacktraces():
code = []
for threadId, stack in sys._current_frames().items():
code.append("\n# ThreadID: %s" % threadId)
for filename, lineno, name, line in traceback.extract_stack(stack):
code.append('File: "%s", line %d, in %s' % (filename,
lineno, name))
if line:
code.append(" %s" % (line.strip()))
for line in code:
print >> sys.stderr, line
The caveat here obviously is that the process has to still be running. There is also the issue of how you trigger that function to dump stack traces for executing Python threads.
If the problem you have is that some request handler threads are stuck, either blocked, or stuck in an infinite loop, and you want to know what they are doing, then so long as there are still some handler threads left and the application is still responding to requests, then you could trigger it from a request handler triggered by making a request against a specific URL.
This though depends on you only running your application within a single process because as soon as you have multiple processes you have no guarantee that a request will go to the process you want to debug.
A better method therefore is to have a perpetually running background thread which monitors for a specific file in the file system. When that file is created or the modification time changes, then the background thread would dump the stack traces for the process.
Sample code which takes this approach is included below. This code could be placed temporarily at the end of your WSGI script file if you know you are going to need it because of a recurring problem:
import os
import sys
import time
import signal
import threading
import atexit
import Queue
import traceback
FILE = '/tmp/dump-stack-traces.txt'
_interval = 1.0
_running = False
_queue = Queue.Queue()
_lock = threading.Lock()
def _stacktraces():
code = []
for threadId, stack in sys._current_frames().items():
code.append("\n# ProcessId: %s" % os.getpid())
code.append("# ThreadID: %s" % threadId)
for filename, lineno, name, line in traceback.extract_stack(stack):
code.append('File: "%s", line %d, in %s' % (filename,
lineno, name))
if line:
code.append(" %s" % (line.strip()))
for line in code:
print >> sys.stderr, line
try:
mtime = os.path.getmtime(FILE)
except:
mtime = None
def _monitor():
while 1:
global mtime
try:
current = os.path.getmtime(FILE)
except:
current = None
if current != mtime:
mtime = current
_stacktraces()
# Go to sleep for specified interval.
try:
return _queue.get(timeout=_interval)
except:
pass
_thread = threading.Thread(target=_monitor)
_thread.setDaemon(True)
def _exiting():
try:
_queue.put(True)
except:
pass
_thread.join()
atexit.register(_exiting)
def _start(interval=1.0):
global _interval
if interval < _interval:
_interval = interval
global _running
_lock.acquire()
if not _running:
prefix = 'monitor (pid=%d):' % os.getpid()
print >> sys.stderr, '%s Starting stack trace monitor.' % prefix
_running = True
_thread.start()
_lock.release()
_start()
Once your WSGI script file has been loaded, then touching the file ‘/tmp/dump-stack-traces.txt’ will cause stack traces for active Python threads to be output to the Apache error log.
Note that the sample code doesn’t deal with possibility that with multiple processes for same application, that all processes may attempt to dump information at the same time. As such, you may get interleaving of output from multiple processes in Apache error logs at the same time.
What you may want to do is modify this code to dump out to some special directory, distinct files containing the trace where the names of the file include the process ID and a date/time. That way each will be separate.
An example of what one might expect to see from the above code is as follows:
# ProcessId: 666
# ThreadID:<PHONE_NUMBER>
File: "/System/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/threading.py", line 497, in __bootstrap
self.__bootstrap_inner()
File: "/System/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/threading.py", line 522, in __bootstrap_inner
self.run()
File: "/System/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/threading.py", line 477, in run
self.__target(*self.__args, **self.__kwargs)
File: "/Library/WebServer/Sites/django-1/htdocs/project.wsgi", line 72, in _monitor
_stacktraces()
File: "/Library/WebServer/Sites/django-1/htdocs/project.wsgi", line 47, in _stacktraces
for filename, lineno, name, line in traceback.extract_stack(stack):
# ThreadID:<PHONE_NUMBER>
File: "/Library/WebServer/Sites/django-1/htdocs/project.wsgi", line 21, in application
return _application(environ, start_response)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/core/handlers/wsgi.py", line 245, in __call__
response = middleware_method(request, response)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/contrib/sessions/middleware.py", line 36, in process_response
request.session.save()
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/contrib/sessions/backends/db.py", line 63, in save
obj.save(force_insert=must_create, using=using)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/db/models/base.py", line 434, in save
self.save_base(using=using, force_insert=force_insert, force_update=force_update)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/db/models/base.py", line 527, in save_base
result = manager._insert(values, return_id=update_pk, using=using)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/db/models/manager.py", line 195, in _insert
return insert_query(self.model, values, **kwargs)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/db/models/query.py", line 1479, in insert_query
return query.get_compiler(using=using).execute_sql(return_id)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/db/models/sql/compiler.py", line 783, in execute_sql
cursor = super(SQLInsertCompiler, self).execute_sql(None)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/django/db/models/sql/compiler.py", line 727, in execute_sql
cursor.execute(sql, params)
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/debug_toolbar/panels/sql.py", line 95, in execute
stacktrace = tidy_stacktrace(traceback.extract_stack())
File: "/Library/WebServer/Sites/django-1/lib/python2.6/site-packages/debug_toolbar/panels/sql.py", line 40, in tidy_stacktrace
s_path = os.path.realpath(s[0])
File: "/System/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/posixpath.py", line 355, in realpath
if islink(component):
File: "/System/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/posixpath.py", line 132, in islink
st = os.lstat(path)
Note that one of the displayed threads will be that for the thread which is dumping the stack traces. That stack trace can obviously be ignored.
One could extend the above recipe in more elaborate ways by using a WSGI middleware that capture details of each request from the WSGI environment and also dumping out from that the URL for the request being handled by any threads. This may assist in working out whether problems are related to a specific URL.


Here's an example of am outlined red and white Line chart. It's achieved by
using two Line charts, one on top of the other. And with the linewidth of
the underlying line chart a couple of points bigger than the upper Line
chart. This could be done using just a single SVG tag but this uses two
that are positioned on top of each other. It also uses the trace()
effect
(on both Line charts).
 Put this where you want the chart to show up:

This is the code that generates the chart - it should be placed AFTER the

tag:


Home
About
Products
Contact
Contact us
We are always ready to answer your questions and help you.
Get in touch with us
Submit


You have 3 unread notification
Congratulate! New User Joined
Data Cleansing Your data has been received
Account Setup Finish setting up your account and adding more users.
Member since June 2020


Money Play. How should Red play 42?
pips Red=84 White=73
(CorrectAnswer= 0/0, ErrorScore= 0)
The blot on White's 3-pt gives Red tactical opportunities. With the 3-pt made he would have to play 6/2, 4/2 but here he can venture 17/15, 5/1 or 17/11. The former is the stronger play, generating more shots/hits.
In this position 6/2, 4/2 is a bad error.
Attention to detail is vital in backgammon!
In this position 6/2, 4/2 is a bad error.
Attention to detail is vital in backgammon!
1. Cubeful 2-ply 17/11 Eq.: -0.274 0.319 0.050 0.003 - 0.681 0.041 0.001 2. Cubeful 2-ply 6/2 4/2 Eq.: -0.281 (-0.007) 0.311 0.003 0.000 - 0.689 0.009 0.000 3. Cubeful 2-ply 5/1 4/2 Eq.: -0.299 (-0.025) 0.303 0.004 0.000 - 0.697 0.009 0.000 4. Cubeful 2-ply 5/1 3/1 Eq.: -0.315 (-0.041) 0.295 0.002 0.000 - 0.705 0.004 0.000 5. Cubeful 2-ply 17/13 5/3 Eq.: -0.320 (-0.046) 0.302 0.035 0.002 - 0.698 0.039 0.001


Home
QR Scan
SUGGESTION
TABLETS
Select...
FEVER
JAUNDICE
TYPHOID
MALARIA
LIVER DISEASE
Naproxen Suspention.
MORNING
AFTERNOON
EVENING
NIGHT
Ibuprofen Suspension.
MORNING
AFTERNOON
EVENING
NIGHT
Acetaminophen.
MORNING
AFTERNOON
EVENING
NIGHT
Excedrin Migraine.
MORNING
AFTERNOON
EVENING
NIGHT
naproxen.
MORNING
AFTERNOON
EVENING
NIGHT
indomethacin.
MORNING
AFTERNOON
EVENING
NIGHT
ibuprofen.
MORNING
AFTERNOON
EVENING
NIGHT
indocin.
MORNING
AFTERNOON
EVENING
NIGHT
Excedrin.
MORNING
AFTERNOON
EVENING
NIGHT
Aspergum.
MORNING
AFTERNOON
EVENING
NIGHT
Acephen.
MORNING
AFTERNOON
EVENING
NIGHT
Mapap.
MORNING
AFTERNOON
EVENING
NIGHT
Easprin.
MORNING
AFTERNOON
EVENING
NIGHT
Ecotrin.
MORNING
AFTERNOON
EVENING
NIGHT
Anaprox.
MORNING
AFTERNOON
EVENING
NIGHT
Tylenol 25mg-500mg tablet.
MORNING
AFTERNOON
EVENING
NIGHT
Aspirin capsule,Extended release 24hr.
MORNING
AFTERNOON
EVENING
NIGHT
Motrin tablet.
MORNING
AFTERNOON
EVENING
NIGHT
Advil tablet,chewable.
MORNING
AFTERNOON
EVENING
NIGHT
Bayer PM.
MORNING
AFTERNOON
EVENING
NIGHT
Genebs tablet.
MORNING
AFTERNOON
EVENING
NIGHT
Pain reliver liquid.
MORNING
AFTERNOON
EVENING
NIGHT
Mapap PM.
MORNING
AFTERNOON
EVENING
NIGHT
Pain relief tablet,extended release.
MORNING
AFTERNOON
EVENING
NIGHT
Children's Advil tablet,chewable.
MORNING
AFTERNOON
EVENING
NIGHT
Haltran tablet.
MORNING
AFTERNOON
EVENING
NIGHT
Frendol tablet.
MORNING
AFTERNOON
EVENING
NIGHT


About Me
Hi, I'm Suman Saha. I am a Professional Services Consultant based in Kolkata, West Bengal, India. I have 10 years of experience in consulting for enterprise content management and other software development roles and I'm passionate about automating as many processes as I can.

Skills
- Epicor Enterprise Content Management
- Epicor Kinetic and SLS
- SQL
- Basic C#
Education
- Bachelor of Technology in Computer Science and Engineering from Govt. College of Engineering and Creamic Tech, Kolkata in 2013


| {{ log.meta }} | {{ log.content }} |
Click on a player in the Match info to the left to display the Journal! (Whether or not a journal can be displayed depends on if it's shipped in the report data, thus the display may not always work)
{{ line }}
Click on a player in the match info to the left to display their Journal! (Whether or not a journal can be displayed depends on if it's shipped in the report data, thus the display may not always work)
{{ line }}


@(app: Application) @main("2PN") {
2PN is a popular single-player game for Web and mobile. It's a kind of puzzle game and of course playable
for each age class.
Basically, 2048 presents with a 4x4 grid. When you start the game, there will be two “tiles” on the
grid, each displaying the number 2 or 4. You hit the arrow keys on your keyboard to move the tiles around —
and also to generate new tiles, which will also be valued at 2 or 4. When two equal tiles collide, they
combine to give you one greater tile that displays their sum. The more you do this, obviously, the higher
the tiles get and the more crowded the board becomes. Your objective is to reach 2048 before the board fills
up.
Fore more information follow Wikipedia


The adventures of writer Newt Scamander in New York's secret community of witches and wizards seventy years before Harry Potter reads his book in school.
The Rebellion makes a risky move to steal the plans to the Death Star, setting up the epic saga to follow.
$9.50 per ticket – Adults 5 p.m. and later
$8 per ticket – Adults before 5 p.m.
$6.50 per ticket – children 12 years old and under
• All shows are 21 and over; minors are welcome
if accompanied by a parent or guardian.
• $1 online purchase fee per ticket
Doors open 30 minutes before the first matinee, 45 minutes before the second matinee, 60 minutes before the 7 p.m., and 30 minutes before the late show. Keep in mind, food is delivered only to the balcony seats. Just order at concessions, grab a seat in the balcony, and we'll bring it to you!
Come experience our new 50% larger screen, 20,000-watt surround sound, state-of-the-art digital projector and new luxurious rocker seating at Portland’s Bagdad Theater!
Our theater offers a quality entertainment experience for deaf, hard of hearing and vision impaired guests. Our movie showings are closed captioned, and we offer individual Captiview closed caption devices that sit in your seat’s cupholder. In addition, we offer two types of headphones: hearing impaired headphones that amplify the dialogue, or visual impaired headphones that describe the scenery and action. Just inquire before showtime to use any of these devices.


% if(n_total > 0) { %> <% if(n_used > 0) { %>
In total, <%=pkg$package%> has <%=n_total%> upstream package<%=ifelse(n_total > 1, 's', '')%>. Only <%=n_used%> upstream packages with heaviness on <%=pkg$package%> larger than 5 are listed in the following table. Note all 14 base packages (base, compiler, datasets, graphics, grDevices, grid, methods, parallel, splines, stats, stats4, tcltk, tools and utils) are excluded from this table.
Dependency path: the shortest path from an upstream package to <%=pkg$package%> in the global dependency graph. The form of A→
kB means package A contributes a direct heaviness of k on package B.
Heaviness on <%=pkg$package%>: Denote $n_{1k}$ as the number of strong dependencies of <%=pkg$package%>. Since the upstream package can affect <%=pkg$package%> in an indirect manner, we recalculate the global dependency relations for all packages after moving the upstream package to all its child packages' Suggests
. Then we denote $n_{2k}$
as the number of strong dependencies of <%=pkg$package%> in the reduced dependency graph. The heaviness from upstream package is calculated as $n_{1k} - n_{2k}$.
The full table can be obtained by:
library(pkgndep) pkgndep_opt$heaviness_db_version = "<%=pkgndep_opt$heaviness_db_version%>" upstream_dependency("<%=pkg$package%>")<% el = upstream_dependency(pkg$package) g = igraph::graph.edgelist(as.matrix(unique(el[, 1:2]))) for(i in seq_len(nrow(upstream_tb))) { sp = igraph::all_shortest_paths(g, upstream_tb[i, 1], pkg$package)$res upstream_tb[i, "path"] = paste(sapply(sp, function(x) { p = names(x) txt = paste0("
Dependency paths in the table are merged into the following graph with <%=length(unique(c(nt[, 1], nt[, 2])))%> nodes and <%=nrow(nt)%> edges. Reset graph | Horizontal layout
There are the two notes for the following graph:
k1
heaviness from A to B is not necessarily all passed to package C, because it might be diluted by C's other parents.In total there are <%=n_total%> upstream dependencies, but no upstream package has heaviness larger than 5 on '<%=pkg$package%>'.
<% } %> <% } else { %>No upstream dependency (not including base packages) found.
<% } %>


Table of Content
Importing USAspending into SQL Server
Stripping descriptions from USAspending fields
Tips using SSIS SQL server
Ways of counting in FPDS


Task:
{{ task.name }}
{{ task.program }}
{{ task.description }}
{{ task.start_date }}
{{ task.no_of_submissions }}
Participants who have completed tasks!!
{% for submission in submissions %}
{{ submission.participant.full_name }}
{{ submission.completion_date }}
{% endfor %}


Simple app demostration. Do you know pending navigations pattern? That's why este app presenters are async by design. It's crucial for good UX.
Try click to products/0, then before request is finished, click to products/1. First click will be canceled. Try several fast clicks on the same link. Only first click will be processed. Detail Presenter uses timeouts for slow connection simulation. products/0 is timeouted by 6s, others products by 2s.
Default app timeout is 10s. Then timeout error is shown and user can repeat action. Loading errors are also detected. Both error and timeout are shown via window.alert by default. It can be disabled via showAlertOnError option.


10
1 Israel is a luxuriant vine that produces his fruit.
As his fruit increased,
the more altars he built.
As his land produced more,
he improved his sacred pillars.
2 Their heart is deceitful;
now they must bear their guilt.
Yahweh will demolish their altars;
he will destroy their sacred pillars.
3 For now they will say,
"We have no king,
for we do not fear Yahweh.
And a king—what could he do for us?"
4 They speak empty words
and make covenants by swearing falsely.
So justice springs up
like poisonous weeds in the furrows of a field.
5 The inhabitants of Samaria will be afraid
because of the calves of Beth Aven.
Its people mourned over them,
as did those idolatrous priests who had rejoiced over them
and their splendor,
but they are no longer there.
6 They will be carried to Assyria
for a present for the great king.
Ephraim will be disgraced,
and Israel will be ashamed for following the advice of idols.
7 Samaria's king
will be destroyed,
like a chip of wood on the surface of the water.
8 The shrines of wickedness—the sin of Israel—
will be destroyed.
Thorns and thistles will grow over their altars.
The people will say to the mountains, "Cover us!"
and to the hills, "Fall on us!"
9 "Israel,
you have sinned since the days of Gibeah;
there you have remained.
Did not war overtake the evildoers in Gibeah?
10 When I desire it, I will discipline them.
The nations will gather together against them
and put them in bonds for their double iniquity.
11 Ephraim is a trained heifer that loves to thresh the grain,
so I will put a yoke on her fair neck.
I will put a yoke on Ephraim;
Judah will plow;
Jacob will pull the harrow by himself.
12 Sow righteousness for yourselves,
and reap the fruit of covenant faithfulness.
Break up your unplowed ground,
for it is time to seek Yahweh,
until he comes and rains righteousness on you.
13 You have plowed wickedness;
you reaped injustice.
You have eaten the fruit of deception
because you trusted in your plans
and in your many soldiers.
14 So a tumult of war will rise among your people,
and all your fortified cities will be destroyed.
It will be as Shalman destroyed Beth Arbel on a day of battle,
when mothers were dashed to pieces with their children.
15 So it will happen to you, Bethel,
because of your great wickedness.
At daybreak the king of Israel will be completely cut off."


本书pdf是文字识别版，影印质量很好。
1.1 Spectroscopy and Electromagnetic Radiations
1.2 Characteristics of Electromagnetic Radiations
1.3 Solved Problems
1.4 Electromagnetic Spectrum
1.5 Absorption and Emission Spectra
2.1 Introduction
2.2 Absorption Laws and Molar Absorptivity
2.3 Instrumentation
2.4 Sample Handling
2.5 Theory (Origin) of UV-Visible Spectroscopy
2.6 Electronic Transitions
2.7 Formation of Absorption Bands
2.8 Designation of Absorption Bands
2.9 Transition Probability: Allowed and Forbidden Transitions
2.10 Certain Terms Used in Electronic Spectroscopy: Definitions
2.11 Conjugated Systems and Transition Energies
2.12 Solvent Effects
2.13 Woodward-Fieser Rules for Calculating $\lambda_{max}$ in Conjugated Dienes and Trienes
2.14 Polyenes and Poly-ynes
2.15 Woodward-Fieser Rules for Calculating $\lambda_{max}$ in $\alpha,\beta$-Unsaturated Carbonyl Compounds
2.16 Dicarbonyl Compounds
2.17 $\alpha,\beta$-Unsaturated Carboxylic Acids and Esters
2.18 Benzene and Its Derivatives
2.19 Polynuclear Aromatic Compounds
2.20 Non-benzenoid Aromatic Compounds
2.21 Heteroaromatic Compounds
2.22 Applications of Ultraviolet and Visible Spectroscopy
3.1 Introduction
3.2 Instrumentation
3.3 Sample Handling
3.4 Theory (Origin) of Infrared Spectroscopy
3.5 Number of Fundamental Vibrations
3.6 Calculation of Vibrational Frequencies
3.7 Factors Affecting Vibrational Frequencies
3.8 Characteristic Absorptions in Common Classes of Compounds
3.9 Fingerprint Region
3.10 Applications of Infrared Spectroscopy
3.11 Interpretation of Infrared Spectra
3.12 Some Solved Problems
4.1 Introduction
4.2 Raman Effect and Origin of Raman Spectroscopy
4.3 Theories of Raman Effect and Raman Spectroscopy
4.4 Zero-Point Energy
4.5 Vibrational Raman Spectra
4.6 Pure Rotational Raman Spectra
4.7 Types of Molecules and Rotational Raman Spectra
4.8 Vibrational-Rotational Raman Spectra
4.9 Polarization of Raman Lines
4.10 Rule of Mutual Exclusion
4.11 Instrumentation
4.12 Sample Handling
4.13 Applications of Raman Spectroscopy
4.14 Difference Between Raman and Fluorescence Spectra
4.15 Difference Between Raman and IR Spectra
4.16 Some Solved problems
5.1 Introduction
5.2 Theory
5.3 Instrumentation
5.4 Sample Handling
5.5 Shielding, Deshielding and Chemical Shift
5.6 Measurement of Chemical Shift: NMR Scale
5.7 Factors Affecting Chemical Shift
5.8 Number of PMR Signals: Equivalent and Nonequivalent Protons
5.9 Peak Area and Proton Counting
5.10 Spin-Spin Splitting: Spin-Spin Coupling
5.11 Coupling Constant (J)
5.12 Analysis (Interpretation) of NMR Spectra
5.13 Nomenclature of Spin Systems
5.14 Magnetic Equivalence
5.15 Spin-Spin Coupling of Protons with Other Nuclei
5.16 Protons on Heteroatoms: Proton Exchange Reactions
5.17 Simplification of Complex NMR Spectra
5.18 Nuclear Overhauser Effect (NOE)
5.19 Applications of PMR Spectroscopy
5.20 Continuous Wave (CW) and Fourier Transform (FT) NMR Spectroscopy
5.21 Some Solved Problems
6.1 Introduction and Theory
6.2 Sample Handling
6.3 Common Modes of Recording $\ce{^13C}$ Spectra
6.4 Chemical Shift Equivalence
6.5 $\ce{^13C}$ Chemical Shifts
6.6 Factors Affecting $\ce{^13C}$ Chemical Shifts
6.7 $\ce{^13C}$ Chemical Shifts (ppm from TMS) of Some Compounds
6.8 Spin-Spin Coupling
6.9 Effect of Deuterium Substitution on CMR Signals
6.10 Use of Shift Reagents
6.11 Applications of CMR Spectroscopy
6.12 Some Solved Problems
7.1 Introduction
7.2 Theory
7.3 ESR Absorption Positions: The $g$ Factor
7.4 Instrumentation
7.5 Working of an ESR Spectrometer
7.6 Sample Handling
7.7 Sensitivity of an ESR Spectrometer
7.8 Multiplet Structures in ESR Spectroscopy
7.9 Interpretation of ESR Spectra
7.10 Double Resonance (or Double Irradiation) in ESR Spectroscopy
7.11 Applications of ESR Spectroscopy
7.12 Comparison Between NMR and ESR Spectroscopy
7.13 Some Solved Problems
8.1 Introduction
8.2 Ionization Methods
8.3 Molecular and Fragment Ions
8.4 Instrumentation
8.5 Double Focusing Mass Spectrometers
8.6 Mass Spectrum and the Base Peak
8.7 Recognition of the Molecular Ion (Parent) Peak and Detection of Isotopes
8.8 Confirmation of the Recognized Molecular Ion Peak
8.9 Multiply Charged Ions
8.10 Metastable Ions or Peaks
8.11 Applications of Mass Spectroscopy
8.12 Representation of Fragmentation Processes
8.13 Factors Governing General Fragmentation Processes
8.14 Examples of General Fragmentation Modes
8.15 Fragmentation Modes of Various Classes of Organic Compounds
8.16 Some Solved Problems
9.1 Introduction
9.2 Some Solved Problems


her(story)
Play Intro
Take Tour
Credits
Credits
Created By
Samantha Levine
Special Thanks
Family member names
Family member names
Family member names
Website By
Matthew Mitchell
Sponsors
Your browser does not support audio playback


--- layout: default ---
Hello
This is my website.
I don't update it as much as I used to. You might be able to catch new code experiments over at GitHub, some photography on Flickr or new music on Albatros' website.
Email me at<EMAIL_ADDRESS>if you want to get ahold of me.
Or grab a copy of my resume if you want to know what I've been up to lately.
Cheers


In a breadth-first search, we pick a node to initially visit into a queue and mark that it has been visited. We then repeatedly remove a node from the queue, and add its unvisited adjacent nodes into the queue, marking them visited. This loops until the queue is empty.
Due to the first-in, first-out nature of the queue, nodes are visited in order of shortest distance from the initial node. The shortest distance property only holds for unweighted graphs.


text2text¶
t2t¶
Input pipeline for the transformer model to read, filter, and batch examples.
Two things to note in the pipeline:
Batching scheme
- The examples encoded in the TFRecord files contain data in the format:
- {“inputs”: [variable length array of integers],
“targets”: [variable length array of integers]}
Where integers in the arrays refer to tokens in the English and German vocab file (named vocab.ende.32768).
Prior to batching, elements in the dataset are grouped by length (max between “inputs” and “targets” length). Each group is then batched such that:
group_batch_size * length <= batch_size.
Another way to view batch_size is the maximum number of tokens in each batch.
- Once batched, each element in the dataset will have the shape:
- {“inputs”: [group_batch_size, padded_input_length],
“targets”: [group_batch_size, padded_target_length]}
Lengths are padded to the longest “inputs” or “targets” sequence in the batch (padded_input_length and padded_target_length can be different).
This batching scheme decreases the fraction of padding tokens per training batch, thus improving the training speed significantly.
Shuffling
While training, the dataset is shuffled in two places in the code. The first is the list of training files. Second, while reading records using parallel_interleave, the sloppy argument is used to generate randomness in the order of the examples.
Modified slightly to fit OpenSeq2Seq needs
-
data.text2text.t2t.
_batch_examples
(dataset, batch_size, max_length, pad_2_eight=True)[source]¶ Group examples by similar lengths, and return batched dataset.
Each batch of similar-length examples are padded to the same length, and may have different number of elements in each batch, such that:
group_batch_size * padded_length <= batch_size.This decreases the number of padding tokens per batch, which improves the training speed.
Parameters: - dataset – Dataset of unbatched examples.
- batch_size – Max number of tokens per batch of examples.
- max_length – Max number of tokens in an example input or target sequence.
Returns: Dataset of batched examples with similar lengths.
-
data.text2text.t2t.
_create_min_max_boundaries
(max_length, min_boundary=8, boundary_scale=1.1)[source]¶ Create min and max boundary lists up to max_length.
For example, when max_length=24, min_boundary=4 and boundary_scale=2, the returned values will be:
buckets_min = [0, 4, 8, 16, 24] buckets_max = [4, 8, 16, 24, 25]Parameters: - max_length – The maximum length of example in dataset.
- min_boundary – Minimum length in boundary.
- boundary_scale – Amount to scale consecutive boundaries in the list.
Returns: min and max boundary lists
-
data.text2text.t2t.
_filter_max_length
(example, max_length=256)[source]¶ Indicates whether the example’s length is lower than the maximum length.
-
data.text2text.t2t.
_get_example_length
(example)[source]¶ Returns the maximum length between the example inputs and targets.
-
data.text2text.t2t.
_parse_example
(serialized_example, pad_2_eight=False)[source]¶ Return inputs and targets Tensors from a serialized tf.Example.
-
data.text2text.t2t.
_read_and_batch_from_files
(file_pattern, batch_size, max_length, num_cpu_cores, shuffle, repeat, num_workers, worker_id, batch_in_tokens, pad2eight=True)[source]¶ Create dataset where each item is a dict of “inputs” and “targets”.
Parameters: - file_pattern – String used to match the input TFRecord files.
- batch_size – Maximum number of tokens per batch of examples
- max_length – Maximum number of tokens per example
- num_cpu_cores – Number of cpu cores for parallel input processing.
- shuffle – If true, randomizes order of elements.
- repeat – Number of times to repeat the dataset. If None, the dataset is repeated forever.
- num_workers – Number of workers or number of Horovod workers
- worker_id – Worker id or Horovod rank
- batch_in_tokens – whether to batch_size means amounts in tokens or sentence
- batching in tokens is more efficient as it reduces PADs. batching in (pairs.) –
- should be used in inference mode since order of (sentences) –
- is important (sentences) –
- pad2eight – if True, it will pad both dimensions to be divisible by 8
Returns: tf.data.Dataset object containing examples loaded from the files.
text2text¶
-
class
data.text2text.text2text.
ParallelTextDataLayer
(params, model, num_workers=1, worker_id=0)[source]¶ Bases:
open_seq2seq.data.data_layer.DataLayer
-
static
get_optional_params
()[source]¶ Static method with description of optional parameters.
Returns: Dictionary containing all the parameters that can be included into the params
parameter of the class__init__()
method.Return type: dict
-
static
get_required_params
()[source]¶ Static method with description of required parameters.
Returns: Dictionary containing all the parameters that have to be included into the params
parameter of the class__init__()
method.Return type: dict
-
get_size_in_samples
()[source]¶ Should return the dataset size in samples. That is, the number of objects in the dataset. This method is used to calculate a valid epoch size. If this method is not defined, you will need to make sure that your dataset for evaluation is created only for one epoch. You will also not be able to use
num_epochs
parameter in the base config.Returns: dataset size in samples. Return type: int
-
input_tensors
¶ Dictionary containing input tensors. This dictionary has to define the following keys: source_tensors, which should contain all tensors describing the input object (i.e. tensors that are passed to the encoder, e.g. input sequence and input length). And when
self.params['mode'] != "infer"
data layer should also define target_tensors which is the list of all tensors related to the corresponding target object (i.e. tensors taht are passed to the decoder and loss, e.g. target sequence and target length). Note that all tensors have to be created insideself.build_graph()
method.
-
iterator
¶ tf.data.Dataset
iterator. Should be created byself.build_graph()
.
-
static
-
class
data.text2text.text2text.
SpecialTextTokens
[source]¶ Bases:
enum.Enum
An enumeration.
-
END_OF_CHOICE
= -100¶
-
EOS_ID
= 1¶
-
OUT_OF_BUCKET
=<PHONE_NUMBER>¶
-
PAD_ID
= 0¶
-
S_ID
= 2¶
-
UNK_ID
= 3¶
-
-
class
data.text2text.text2text.
TransformerDataLayer
(params, model, num_workers=1, worker_id=0)[source]¶ Bases:
open_seq2seq.data.data_layer.DataLayer
Wraps Transformers data pipeline into the form for OpenSeq2Seq
-
static
get_optional_params
()[source]¶ Static method with description of optional parameters.
Returns: Dictionary containing all the parameters that can be included into the params
parameter of the class__init__()
method.Return type: dict
-
static
get_required_params
()[source]¶ Static method with description of required parameters.
Returns: Dictionary containing all the parameters that have to be included into the params
parameter of the class__init__()
method.Return type: dict
-
input_tensors
¶ Dictionary containing input tensors. This dictionary has to define the following keys: source_tensors, which should contain all tensors describing the input object (i.e. tensors that are passed to the encoder, e.g. input sequence and input length). And when
self.params['mode'] != "infer"
data layer should also define target_tensors which is the list of all tensors related to the corresponding target object (i.e. tensors taht are passed to the decoder and loss, e.g. target sequence and target length). Note that all tensors have to be created insideself.build_graph()
method.
-
iterator
¶ tf.data.Dataset
iterator. Should be created byself.build_graph()
.
-
static
tokenizer¶
Defines Subtokenizer class to encode and decode strings.
-
class
data.text2text.tokenizer.
Subtokenizer
(vocab_file, reserved_tokens=None)[source]¶ Bases:
object
Encodes and decodes strings to/from integer IDs.
-
__init__
(vocab_file, reserved_tokens=None)[source]¶ Initializes class, creating a vocab file if data_files is provided.
-
_subtoken_ids_to_tokens
(subtokens)[source]¶ Convert list of int subtoken ids to a list of string tokens.
-
static
init_from_files
(vocab_file, files, target_vocab_size, threshold, min_count=None, file_byte_limit=1000000.0, reserved_tokens=None)[source]¶ Create subtoken vocabulary based on files, and save vocab to file.
Parameters: - vocab_file – String name of vocab file to store subtoken vocabulary.
- files – List of file paths that will be used to generate vocabulary.
- target_vocab_size – target vocabulary size to generate.
- threshold – int threshold of vocabulary size to accept.
- min_count – int minimum count to use for generating the vocabulary. The min count is the minimum number of times a subtoken should appear in the files before it is added to the vocabulary. If set to none, this value is found using binary search.
- file_byte_limit – (Default 1e6) Maximum number of bytes of sample text that will be drawn from the files.
- reserved_tokens – List of string tokens that are guaranteed to be at the beginning of the subtoken vocabulary list.
Returns: Subtokenizer object
-
-
data.text2text.tokenizer.
_count_and_gen_subtokens
(token_counts, alphabet, subtoken_dict, max_subtoken_length)[source]¶ Count number of times subtokens appear, and generate new subtokens.
Parameters: - token_counts – dict mapping tokens to the number of times they appear in the original files.
- alphabet – list of allowed characters. Used to escape the tokens, which guarantees that all tokens can be split into subtokens.
- subtoken_dict – dict mapping subtokens to ids.
- max_subtoken_length – maximum length of subtoken in subtoken_dict.
Returns: A defaultdict mapping subtokens to the number of times they appear in the tokens. The dict may contain new subtokens.
-
data.text2text.tokenizer.
_count_tokens
(files, file_byte_limit=1000000.0)[source]¶ Return token counts of words in the files.
Samples file_byte_limit bytes from each file, and counts the words that appear in the samples. The samples are semi-evenly distributed across the file.
Parameters: - files – List of filepaths
- file_byte_limit – Max number of bytes that will be read from each file.
Returns: Dictionary mapping tokens to the number of times they appear in the sampled lines from the files.
-
data.text2text.tokenizer.
_escape_token
(token, alphabet)[source]¶ Replace characters that aren’t in the alphabet and append “_” to token.
- Apply three transformations to the token:
- Replace underline character “_” with “u”, and backslash “” with “".
- Replace characters outside of the alphabet with “###;”, where ### is the character’s Unicode code point.
- Appends “_” to mark the end of a token.
Parameters: - token – unicode string to be escaped
- alphabet – list of all known characters
Returns: escaped string
-
data.text2text.tokenizer.
_filter_and_bucket_subtokens
(subtoken_counts, min_count)[source]¶ Return a bucketed list of subtokens that are filtered by count.
Parameters: - subtoken_counts – defaultdict mapping subtokens to their counts
- min_count – int count used to filter subtokens
Returns: List of subtoken sets, where subtokens in set i have the same length=i.
-
data.text2text.tokenizer.
_gen_new_subtoken_list
(subtoken_counts, min_count, alphabet, reserved_tokens=None)[source]¶ Generate candidate subtokens ordered by count, and new max subtoken length.
Add subtokens to the candiate list in order of length (longest subtokens first). When a subtoken is added, the counts of each of its prefixes are decreased. Prefixes that don’t appear much outside the subtoken are not added to the candidate list.
- For example:
- subtoken being added to candidate list: ‘translate’ subtoken_counts: {‘translate’:10, ‘t’:40, ‘tr’:16, ‘tra’:12, …} min_count: 5
- When ‘translate’ is added, subtoken_counts is updated to:
- {‘translate’:0, ‘t’:30, ‘tr’:6, ‘tra’: 2, …}
The subtoken ‘tra’ will not be added to the candidate list, because it appears twice (less than min_count) outside of ‘translate’.
Parameters: - subtoken_counts – defaultdict mapping str subtokens to int counts
- min_count – int minumum count requirement for subtokens
- alphabet – set of characters. Each character is added to the subtoken list to guarantee that all tokens can be encoded.
- reserved_tokens – list of tokens that will be added to the beginning of the returned subtoken list.
Returns: List of candidate subtokens in decreasing count order, and maximum subtoken length
-
data.text2text.tokenizer.
_generate_alphabet_dict
(iterable, reserved_tokens=None)[source]¶ Create set of characters that appear in any element in the iterable.
-
data.text2text.tokenizer.
_generate_subtokens
(token_counts, alphabet, min_count, num_iterations=4, reserved_tokens=None)[source]¶ Create a list of subtokens in decreasing order of frequency.
Parameters: - token_counts – dict mapping str tokens -> int count
- alphabet – set of characters
- min_count – int minimum number of times a subtoken must appear before it is added to the vocabulary.
- num_iterations – int number of iterations to generate new tokens.
- reserved_tokens – list of tokens that will be added to the beginning to the returned subtoken list.
Returns: Sorted list of subtokens (most frequent first)
-
data.text2text.tokenizer.
_generate_subtokens_with_target_vocab_size
(token_counts, alphabet, target_size, threshold, min_count=None, reserved_tokens=None)[source]¶ Generate subtoken vocabulary close to the target size.
-
data.text2text.tokenizer.
_list_to_index_dict
(lst)[source]¶ Create dictionary mapping list items to their indices in the list.
-
data.text2text.tokenizer.
_load_vocab_file
(vocab_file, reserved_tokens=None)[source]¶ Load vocabulary while ensuring reserved tokens are at the top.
-
data.text2text.tokenizer.
_native_to_unicode
(s)[source]¶ Convert string to unicode (required in Python 2).
-
data.text2text.tokenizer.
_save_vocab_file
(vocab_file, subtoken_list)[source]¶ Save subtokens to file.
-
data.text2text.tokenizer.
_split_string_to_tokens
(text)[source]¶ Splits text to a list of string tokens.
-
data.text2text.tokenizer.
_split_token_to_subtokens
(token, subtoken_dict, max_subtoken_length)[source]¶ Splits a token into subtokens defined in the subtoken dict.
-
data.text2text.tokenizer.
_unicode_to_native
(s)[source]¶ Convert string from unicode to native format (required in Python 2).
-
data.text2text.tokenizer.
join_tokens_to_string
(tokens)[source]¶ Join a list of string tokens into a single string.
-
data.text2text.tokenizer.
unescape_token
(token)[source]¶ Replaces escaped characters in the token with their unescaped versions.
- Applies inverse transformations as _escape_token():
- Replace “u” with “_”, and “" with “”.
- Replace “###;” with the unicode character the ### refers to.
Parameters: token – escaped string Returns: unescaped string


{{template "header"}}
{{template "navbar"}}
Restore Your Site
Danger!
Uploading a backup file will overwrite all current content, images, and templates and restore them from the backup file.
Backup File
Submit
{{template "footer"}}


{% extends 'flask_user/emails/base_message.html' %} {% block message %}
{{ word('Your password has been changed.') }}
{% if user_manager.enable_forgot_password %}{{ word('If you did not initiate this password change,') }} {{ word('click here to reset it') }}.
{% endif %} {% endblock %}


 Since the page
exists, it must have a valid url. But the
url you have entered is invalid.  If that fails, contact the
page owner.
\end{document}


MUSAN is a corpus of music, speech, and noise recordings.
This work was supported by the National Science Foundation Graduate Research Fellowship under Grant No. 1232825 and by Spoken Communications.
You can cite the data using the following BibTeX entry:
@misc{musan2015, author = {David Snyder and Guoguo Chen and Daniel Povey}, title = {{MUSAN}: {A} {M}usic, {S}peech, and {N}oise {C}orpus}, year = {2015}, eprint = {1510.08484}, note = {arXiv:1510.08484v1} }


SELECT
This is to be used in the FORM Tag.
This specifies a Relation List within a Form.
Use the
OPTION Tag to specify items in the
Selection List. This is a Container Tag and thus has to be closed.
Attributes
- DISABLED :
Denies Access to the Selection List
.
- MULTIPLE :
Indicate that a Visitor can select more
than one Selection List Item at the same time.
- NAME :
Gives a Name to the value passed to the Form Processor.
This eshtablishes a Name-Value Pair with which the
Form Processor can Work.
- SIZE :
Specifies the Number of the Variable Items
in the Selection List. If there are more items than those which are
visible, a Scroll Bar provides access to the other items.
Syntax
<FORM>
<SELECT [NAME="NAME"][DISABLED][MULTIPLE][SIZE="n"]>
...
<OPTION>... ...</OPTION>
...
</SELECT>
</FORM>
Example
<FORM>
<SELECT NAME="SELE1">
<OPTION VALUE="VALUE1"> VALUE1 </OPTION>
<OPTIONVALUE="VALUE2"> VALUE2 </OPTION>
</SELECT>
</FORM>
Effect
Home
About


This contest is only for students and aims to demonstrate the latest results in multimedia technologies. To take part in the competition, teams must register and follow the contest rules as outlined below. Teams submit full software products, covering the whole software development process. After a careful evaluation carried out by the Program Committee, several finalist teams will be invited to FC 2019 in KITAKYUSHU, JAPAN and to present and demonstrate their projects and receive their awards in the conference.
Please submit a VIDEO and PDF Document for Fi-Award Competition 2019. Video may be simulations or demonstrations, for example, and can be a great tool to enhance and promote your idea. The video should not exceed 3 minutes and must accompany a PDF document within 4-6 pages by LNEE format [Word] or [Latex]. The video will be sent to peer review with your document for evaluation.
AUTHORS SHOULD SUBMIT THEIR FILES IN FORMAT VIA E-MAIL TO<EMAIL_ADDRESS>Please include "Game Design", "Frontier Computing Applications in Artificial Intelligence" or "Frontier Computing Applications in Interactive Technology" in the email title.
Fi-Award Competition has the two tracks, please choose one track for your project. Each team should include 1 or 2 advisor(s) and do not exceed 5 students.
Game Design: This track is intended to show the game development in mobile, PC and Console, not limited to programming. You can make a case by any popular multimedia authoring tools.
Frontier Computing Applications in Artificial Intelligence or Interactive Technology: Frontier Computing can be used for entertainment, education, museum exhibits and so much more. The original design consists of your innovation or standard patent application in this track. Your end product is only limited by your imagination.
May 4, 2019: Submission for participation closes.
May 20, 2019: Selection of the best teams, among which the finalists of the contest will be selected. The best teams will be asked to submit a final report, which will be included in the finalists.
June 8, 2019: Deadline for the submission of the final PDF document. LNEE Format: [Word] or [Latex]
June 8, 2019: Early-bird registration due
July 9-12, 2019: Conference Dates and final evaluation and presentation of the awards. Awards All finalists will be recognized in the main conference.
The judges will grade entries by the following criteria:
The originality of Concept--Does the project introduce a great new idea?
Effective Use of the Platform --Does the application take advantage of OS and hardware?
Polish and Appeal--Is the application easy to use and aesthetically appealing?
The video and slide should include the various artifacts produced during the development, according to the requests formulated in the project description. Each submitted report will be evaluated by at least 2 members of the Program Committee.
The eventually selected teams will be required to submit a Final PDF Document based on Review Comments. The PDF document should follow the LNEE format within 4-6 pages, [Word] or [Latex]. Those teams will be invited to present and demonstrate their projects in the FC2019 conference. Award winners will be selected during the conference by all-conference participators. The teams are responsible to prepare all the material that is necessary to run and fully evaluate their applications during the conference. Each selected team is requested to register strictly.
Unless exceptions are explicitly stated in advance, all artifacts produced by the teams will be treated confidentially by the PC during the evaluation phase but a copyright release will be requested from the teams selected to submit a full report of their project (see the evaluation procedure).
The application competition is co-chaired by and includes members both from academia and industry. Co-chairs, panel of judges:
Neil Y. Yen, The University of Aizu, Japan
Guan-Hao Tseng, iStuNet Inc., Taipei City, Taiwan
Neil Y. Yen, The University of Aizu, Japan
Yan Pei, The University of Aizu, Japan
Nigel Lin, Santa Clara University, USA
Francisco Isidro Massetto, Universidade Federal do ABC, Brazil
Maiga Chang, Athabasca University, Canada
Jun Shen, University of Wollongong, Australia
Po-Sheng Chiu, National Chiayi University, Taiwan
Ying-Hung Pu, Shu-Te University, Taiwan


| long long int reconnect::creation_time |
| long long int reconnect::last_activity |
| long long int reconnect::last_connected |
| long long int reconnect::last_disconnected |
| int reconnect::max_backoff |
| unsigned int reconnect::max_tries |
| int reconnect::min_backoff |
| unsigned int reconnect::n_attempted_connections |
| unsigned int reconnect::n_successful_connections |
| int reconnect::probe_interval |
| unsigned int reconnect::seqno |
| enum state reconnect::state |
| long long int reconnect::state_entered |
| unsigned int reconnect::total_connected_duration |
The documentation for this struct was generated from the following file:


I'm an Application Developer with industry experience transitioning legacy systems to new applications. I have worked with full stack web development as well as Android mobile applications. I also have experience working with SAP products, Python, and C++.
View Resume
This project uses Clarifai API to detect faces in images. It was built using React, Node.js, HTML, CSS, and JavaScript. It allows the user to upload their image and keeps individual scores based on the amount of images they have uploaded.
The Dungeons & Dragons All-in-one application was created to be intuitive so that playing Dungeons & Dragons is easy. Some features included are:
The application was created using Java for the base code, Python to retrieve and parse APIs, and Google Firestore for the backend.
This application allows a restaruant to fully manage their operations
with one convenient software. It uses security principles to assign
roles to each staff member, allowing them to see an unique screen
according to their responsibilities. It also allows the customers to
order food, ask for help, and play games.
This Android application was created using Java, Github,
and Google Firestore for the backend.
If you would like to work together or contact me, send an email to<EMAIL_ADDRESS>Email me


Thread.stop()
Thread.suspend()
Thread.resume()
These calls are inherently prone to data corruption and deadlock, and their use is strongly discouraged.


Can't find settings file. The module cannot find the default settings file. You need to re-initialize the system. This computer is now crashing GOODBYE!!


The Seabound Soul is the next free update to Sea of Thieves
by Stephany NunneleyThe Seabound Soul is the next update coming to Sea of Thieves.
Sea of Thieves players can enjoy the next free update to the game, The Seabound Soul, starting November 20.
The update features an all-new, lore-focused Tall Tale quest. In it, you will join Captain Pendragon to “uncover the mystery of the feared ship, the Ashen Dragon.”
You will also find out the secrets of a new threat.
With the update comes firebombs which can be thrown or loaded into cannons. The firebombs can be used in both Adventure and in The Arena.
It sounds like fun. Check out the upcoming update in the video below.
Games featured in this article


Overview
Package
Class
Deprecated
Index
Help
Groovy Documentation
PREV NEXT
FRAMES
NO FRAMES
All Classes
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
_
A
afterTransactionBegin
(Transaction)
- Method in
ShardEntityInterceptor
afterTransactionCompletion
(Transaction)
- Method in
ShardEntityInterceptor
applicationContext
- Property in
ShardEntityInterceptor
applicationContext
- Property in
ShardingDS
author
- Property in
ShardingGrailsPlugin
authorEmail
- Property in
ShardingGrailsPlugin
autoCommit
- Property in
Index
autoCommit
- Property in
ShardConfig
B
baseCache
- Field in
ShardCacheWrapper
buildCache
(String, Properties)
- Method in
ShardCacheProvider
BuildConfig
- Class in
grails-app.conf
BuildConfig
()
- Constructor in
BuildConfig
C
capacity
- Property in
ShardConfig
change
(ShardConfig)
- Method in
ShardService
changeByObject
(def)
- Method in
ShardService
clear
()
- Method in
ShardCacheWrapper
constraints
- Property in
Shard
createNode
(Object, Map, Object)
- Method in
IndexBuilder
{
createNode
(Object, Map, Object)
- Method in
ShardBuilder
{
currentIndex
- Property in
IndexBuilder
CurrentShard
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
This class holds the current shard we are pointing, values are stored as thread locals
CurrentShard
()
- Constructor in
CurrentShard
D
dataSource
- Property in
ShardingBootStrap
Datasources
- Class in
grails-app.conf
Datasources
()
- Constructor in
Datasources
dateCreated
- Property in
Shard
The date this record was created;
dependencies
- Class in
DefaultPackage
dependencies
()
- Constructor in
dependencies
dependsOn
- Property in
ShardingGrailsPlugin
description
- Property in
ShardingGrailsPlugin
destroy
()
- Method in
ShardCacheWrapper
destroy
- Property in
ShardingBootStrap
determineCurrentLookupKey
()
- Method in
ShardingDS
dialect
- Property in
Index
documentation
- Property in
ShardingGrailsPlugin
domainClass
- Property in
Index
doWithApplicationContext
- Property in
ShardingGrailsPlugin
doWithDynamicMethods
- Property in
ShardingGrailsPlugin
doWithSpring
- Property in
ShardingGrailsPlugin
doWithWebDescriptor
- Property in
ShardingGrailsPlugin
driverClass
- Property in
Index
driverClass
- Property in
ShardConfig
E
F
G
get
()
- Method in
CurrentShard
get
()
- Method in
Index
get
(Object)
- Method in
ShardCacheWrapper
getAutoCommit
()
- Method in
CurrentShard
Gets whether the current shard is set to Auto Commit
getConnection
()
- Method in
ShardingDS
getElementCountInMemory
()
- Method in
ShardCacheWrapper
getElementCountOnDisk
()
- Method in
ShardCacheWrapper
getIndex
()
- Method in
CurrentShard
Gets the index of the current shard
getIndexDomainClass
()
- Method in
Index
getKey
(Object)
- Method in
ShardCacheWrapper
getNextShard
()
- Method in
ShardService
getPrefix
()
- Method in
ShardCacheWrapper
getRegionName
()
- Method in
ShardCacheWrapper
getShard
(def)
- Method in
ShardService
getSizeInMemory
()
- Method in
ShardCacheWrapper
getTimeout
()
- Method in
ShardCacheWrapper
grailsApplication
- Property in
ShardingBootStrap
grailsVersion
- Property in
ShardingGrailsPlugin
H
I
id
- Property in
Index
id
- Property in
ShardConfig
incrementUsage
- Property in
Shard
Index
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
This class is used to hold the connection info for the INDEX database Date: Jul 5, 2010 Time: 5:53:58 PM
Index
()
- Constructor in
Index
IndexBuilder
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
Reads the index section of the configuration file.
IndexBuilder
()
- Constructor in
IndexBuilder
indexTransaction
- Property in
ShardEntityInterceptor
init
- Property in
ShardingBootStrap
J
jdbcUrl
- Property in
Index
jdbcUrl
- Property in
ShardConfig
K
L
lastUpdated
- Property in
Shard
The date this record was last updated.
list
()
- Method in
Shards
loadIndex
()
- Method in
Index
loadShards
()
- Method in
ShardingGrailsPlugin
lock
(Object)
- Method in
ShardCacheWrapper
M
mapping
- Property in
Shard
N
name
- Property in
Index
name
- Property in
ShardConfig
nextTimestamp
()
- Method in
ShardCacheWrapper
nodeCompleted
(Object, Object)
- Method in
IndexBuilder
{
nodeCompleted
(Object, Object)
- Method in
ShardBuilder
{
O
onChange
- Property in
ShardingGrailsPlugin
onConfigChange
- Property in
ShardingGrailsPlugin
P
password
- Property in
Index
password
- Property in
ShardConfig
pluginExcludes
- Property in
ShardingGrailsPlugin
put
(Object, Object)
- Method in
ShardCacheWrapper
Q
R
ratio
- Property in
Shard
The percentage of the capacity that this shard contains.
read
(Object)
- Method in
ShardCacheWrapper
remove
(Object)
- Method in
ShardCacheWrapper
S
sessionFactory
- Property in
ShardService
set
(Index)
- Method in
Index
setApplicationContext
(ApplicationContext)
- Method in
ShardEntityInterceptor
setApplicationContext
(ApplicationContext)
- Method in
ShardingDS
setAutoCommit
(boolean)
- Method in
CurrentShard
Sets whether the current shard is set to Auto Commit
setParent
(Object, Object)
- Method in
IndexBuilder
{
setParent
(Object, Object)
- Method in
ShardBuilder
{
setShard
(ShardConfig)
- Method in
CurrentShard
Sets the current shard, requires a map that contains a index element that refers to the index for the shard
setUp
()
- Method in
ShardServiceServiceTests
setUp
()
- Method in
ShardTests
Shard
- Class in
grails-app.domain.com.jeffrick.grails.plugins.sharding
This class and table is used to manage all of the database shards within the system.
Shard
()
- Constructor in
Shard
ShardBuilder
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
Created by IntelliJ IDEA.
ShardBuilder
()
- Constructor in
ShardBuilder
ShardCacheProvider
- Class in
src.java.com.jeffrick.hibernate.cache
Simple wrapper of the EhCacheProvider that uses ShardCacheWrapper instead of the default cache.
ShardCacheProvider
()
- Constructor in
ShardCacheProvider
ShardCacheWrapper
- Class in
src.java.com.jeffrick.hibernate.cache
This wrapper provides a prefix for the cache based on the current shard db Date: Feb 14, 2010 Time: 11:30:28 AM
ShardCacheWrapper
(Cache)
- Constructor in
ShardCacheWrapper
shardCapacity
- Property in
Shard
The number of objects (either RSS feeds or Users depending on the type) that this shard can contain.
ShardConfig
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
Created by IntelliJ IDEA.
ShardConfig
()
- Constructor in
ShardConfig
ShardEntityInterceptor
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
This class is used to synchronize the transaction in the shard database with the one in the index database Date: Aug 11, 2009 Time: 3:00:03 PM
ShardEntityInterceptor
()
- Constructor in
ShardEntityInterceptor
ShardingBootStrap
- Class in
grails-app.conf
ShardingBootStrap
()
- Constructor in
ShardingBootStrap
ShardingDS
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
This is an implementation of AbstractRoutingDataSource that reads the current shard we should point to and maintains that connection.
ShardingDS
()
- Constructor in
ShardingDS
ShardingGrailsPlugin
- Class in
DefaultPackage
ShardingGrailsPlugin
()
- Constructor in
ShardingGrailsPlugin
shardName
- Property in
Shard
The name of the shard, used internally to refer to the shard.
shardNameFieldName
- Property in
Index
Shards
- Class in
src.groovy.com.jeffrick.grails.plugin.sharding
Created by IntelliJ IDEA.
shards
- Property in
ShardBuilder
shards
- Property in
Shards
ShardService
- Class in
grails-app.services.com.jeffrick.grails.plugins.services
shardService
- Property in
ShardingBootStrap
ShardService
()
- Constructor in
ShardService
ShardServiceServiceTests
- Class in
test.unit.com.jeffrick.grails.plugins.services
ShardServiceServiceTests
()
- Constructor in
ShardServiceServiceTests
ShardTests
- Class in
test.unit.com.jeffrick.grails.plugins.sharding
ShardTests
()
- Constructor in
ShardTests
shardType
- Property in
ShardingDS
shardUsage
- Property in
Shard
The number of objects (either RSS feeds or Users depending on the type) that this shard currently holds.
T
tearDown
()
- Method in
ShardServiceServiceTests
tearDown
()
- Method in
ShardTests
testSomething
()
- Method in
ShardServiceServiceTests
testSomething
()
- Method in
ShardTests
title
- Property in
ShardingGrailsPlugin
toMap
()
- Method in
ShardCacheWrapper
toString
()
- Method in
Shard
transactional
- Property in
ShardService
transactionManager
- Property in
ShardEntityInterceptor
trnsManager
- Property in
ShardEntityInterceptor
trnsStatus
- Property in
ShardEntityInterceptor
U
unlock
(Object)
- Method in
ShardCacheWrapper
update
(Object, Object)
- Method in
ShardCacheWrapper
user
- Property in
Index
user
- Property in
ShardConfig
V
version
- Property in
ShardingGrailsPlugin
W
X
Y
Z
_
_autoCommit
- Property in
CurrentShard
_configuration
- Property in
ShardingBootStrap
_currentShard
- Property in
ShardBuilder
_currentShardName
- Property in
ShardBuilder
_index
- Property in
Index
_Install
- Class in
scripts
_Install
()
- Constructor in
_Install
_shardIndex
- Property in
CurrentShard
_Uninstall
- Class in
scripts
_Uninstall
()
- Constructor in
_Uninstall
_Upgrade
- Class in
scripts
_Upgrade
()
- Constructor in
_Upgrade
Groovy Documentation