def post(self, request):
	data = request.POST
	try:
		print "uname:" , data['uName']
		print "uPin:" , data['uPin']
		print "MSISDN:" , data['MSISDN']
		print "messageString:" , data['messageString']
		#print "Display:", data['Display']
		#print "udh:", data['udh']
		#print "mwi:", data['mwi']
		#print "coding:", data['coding']
		if str.isdigit(data['MSISDN']) == False:
			print "Bad MSISDN : " , data['MSISDN']
			callback(data['uName'], "STRATLOC")
			return http.ok([('Content-Type', 'text/html')], "<return>501</return>")
		print "----------------------------------------"
		#wait until modem becomes available
		print "Lock : " , gsmlock		
		if (gsmlock == True):
			print "waiting for modem to become available"
			while (gsmlock == True):
				pass
		modem_sendmsg(data['MSISDN'] , data['messageString'])
        	return http.ok([('Content-Type', 'text/html')], "<return>201</return>")
	except:
		return http.ok([('Content-Type', 'text/html')], "<return>506</return>")

 def all(self, request):
     if request.method == "DELETE":
         return http.ok([('Content-Type', 'text/plain')],
                        "THERE IS NO DELETE")
     else:
         return http.ok([('Content-Type', 'text/plain')],
                        request.method)

def render_response(request, page, template, args={},
                    type='text/html', encoding='utf-8',
                    headers=[]):
    """
    Render a page, using the template and args, and return a '200 OK'
    response.  The response's Content-Type header will be constructed from
    the type and encoding.

    :arg request:
        Request instance.
    :arg page:
        Page being rendered (hint, it's often self).
    :arg template:
        Name of the template file.
    :arg args:
        Dictionary of args to pass to the template renderer.
    :arg type:
        Optional mime type of content, defaults to 'text/html'
    :arg encoding:
        Optional encoding of output, default to 'utf-8'.
    :arg headers:
        Optional extra HTTP headers for the output, default to []
    """
    # Copy the headers to avoid changing the arg default or the list passed by
    # the caller.
    headers = list(headers)
    headers.extend([('Content-Type', '%s; charset=%s' % (type, encoding))])
    return http.ok(headers,
                   render_page(request, page, template, args,
                               encoding=encoding))

    def index(self, request, segments):
        def g():
            if isinstance(self.metadata, dict):
                for k,v in sorted(self.metadata.iteritems()):
                    if isinstance(v, dict):
                        yield '{0}/\n'.format(k)
                    elif isinstance(v, list):
                        yield '{0}/\n'.format(k)
                    else:
                        yield '{0}\n'.format(k)
            elif isinstance(self.metadata, list):
                for i, v in enumerate(self.metadata):
                    # it always needs some name (or cloud-init will
                    # write "0=" into ssh authorized_keys), so provide
                    # the index as a default
                    name = '{0}'.format(i)
                    if isinstance(v, Named):
                        name = v.name
                    yield '{0}={1}\n'.format(i, name)
            else:
                raise RuntimeError('Cannot index weird metadata: %r' % self.metadata)

        return http.ok(
            [('Content-Type', 'text/plain')],
            g(),
            )

 def resource(request):
     def gen():
         yield "Three ... "
         yield "two ... "
         yield "one ... "
         yield "BANG!"
     return http.ok([('Content-Type', 'text/plain')], gen())

 def serve(self, request):
     if isinstance(self.metadata, (dict, list)):
         return http.not_found()
     else:
         return http.ok(
             [('Content-Type', 'text/plain')],
             [self.metadata],
             )

 def GET(self, request):
     C = request.environ["couchish"]
     with C.session() as S:
         users = list(S.view("user/all", include_docs=True))
     users = [p.doc for p in users]
     users.sort(key=itemgetter("last_name"))
     out = dictwriter(users, CSVUSERKEYS)
     return http.ok([("Content-Type", "text/csv")], out)

    def __call__(self, request):
        log.debug('formish.FileResource: in File Resource')
        if not self.segments:    
            return None

        # This is our input filepath
        requested_filepath = self._get_requested_filepath()
        log.debug('formish.FileResource: requested_filepath=%s',requested_filepath)
 
        # Get the raw cache file path and mtime
        raw_cached_filepath = self._get_cachefile_path(requested_filepath)
        log.debug('formish.FileResource: raw_cached_filepath=%s',raw_cached_filepath)
        raw_cached_mtime = self._get_file_mtime(raw_cached_filepath)

        # Check to see if fa and temp exist
        tempfile_path = self._get_tempfile_path(requested_filepath)
        log.debug('formish.FileResource: tempfile_path=%s',tempfile_path)

        # work out which has changed most recently (if either is newer than cache)
        fileaccessor_mtime = self._get_fileaccessor_mtime(requested_filepath)
        tempfile_mtime = self._get_file_mtime(tempfile_path)
        source_mtime = max(fileaccessor_mtime, tempfile_mtime)

        # unfound files return a 1970 timestamp for simplicity, if we don't have files newer than 1971, bugout
        if source_mtime < datetime(1971,1,1,0,0):
            return None

        if source_mtime > raw_cached_mtime:
            if fileaccessor_mtime > tempfile_mtime:
                log.debug('formish.FileResource: fileaccessor resource is newer. rebuild raw cache')
                filedata = self.fileaccessor.get_file(requested_filepath)
                mimetype = self.fileaccessor.get_mimetype(requested_filepath)
            else:
                log.debug('formish.FileResource: tempfile resource is newer. rebuilding raw cache')
                filedata = open(tempfile_path).read()
                mimetype = get_mimetype(tempfile_path)
            open(raw_cached_filepath,'w').write(filedata)
        else:
            log.debug('formish.FileResource: raw cache file is valid')
            mimetype = get_mimetype(raw_cached_filepath)

        # If we're trying to resize, check mtime on resized_cache
        size_suffix = self._get_size_suffix(request)
        if size_suffix:
            log.debug('formish.FileResource: size_suffix=%s',size_suffix)
            cached_filepath = self._get_cachefile_path(requested_filepath, size_suffix)
            cached_mtime = self._get_file_mtime(cached_filepath)
            log.debug('formish.FileResource: cached_filepath=%s',cached_filepath)

            if not os.path.exists(cached_filepath) or source_mtime > cached_mtime:
                width, height = get_size_from_dict(request.GET)
                log.debug('formish.FileResource: cache invalid. resizing image')
                resize_image(raw_cached_filepath, cached_filepath, width, height)
        else:
            log.debug('formish.FileResource: resized cache file is valid.')
            cached_filepath = raw_cached_filepath

        return http.ok([('content-type', mimetype )], open(cached_filepath, 'rb').read())

    def status(self, request):
        session = models.Session.get_by_key_name(self.name)
        if session is None:
            return http.not_found([], '')

        return http.ok(
            [('Content-Type', 'application/json')],
            json.dumps({'created_at': str(session.created_at)})
        )

 def user_data(self, request, segments):
     if segments:
         return None
     data = request.environ['cheesy2.userdata'](request)
     if data is not None:
         return http.ok(
             [('Content-Type', 'text/plain')],
             [data],
             )

 def details(self, request):
     try:
         request_id = int(self._request_id)
     except ValueError:
         return http.bad_request()
     resource = self._make_resource(request_id)
     if resource is None:
         return http.not_found()
     return http.ok([], etag(resource))

 def serve(self, request):
     f = pkg_resources.resource_stream(
         'teuthology.html',
         'root.html',
         )
     return http.ok(
         [('Content-Type', 'text/html')],
         f,
         )

 def html(self, request):
     C = request.environ['couchish']
     with C.session() as S:
         results = list(S.view('page/by_url',key='/',include_docs=True))
         news = S.docs_by_view('newsitem/homepage_news')
     news = [n for n in news if n.get('date') and n['date'] < date.today()]
     page = results[0].doc
     sitemap = navigation.get_navigation(request)
     data = {'page': page, 'request': request, 'sitemap': sitemap, 'news':news}
     out = templating.render(request, page['pagetype'], data, encoding='utf-8')
     return http.ok([('Content-Type', 'text/html')], out)

 def json(self, req):
     filter_indexname = req.params.get('indexname', None)
     base_url = '/'.join(req.url.split('/')[:-2])
     indexes = []
     for x in self.pypi.get_indexes(self.distro.distro_id):
         if not filter_indexname:
             indexes.append(x)
             continue
         if filter_indexname == x:
             index = Index(self.pypi, self.distro, x)
             indexes.append(index.get_index_dict(base_url))
     return http.ok([], simplejson.dumps({'indexes': indexes}))

    def scrape(self, request):
        session = models.Session.get_by_key_name(self.name)
        if session is None:
            return http.not_found([], '')

        data = json.loads(request.body)

        content, matched = session.scrape(data['url'], data['match'])

        return http.ok(
            [('Content-Type', 'application/json')],
            json.dumps({'content': content, 'matched': matched})
        )

 def get_configuration(self, request):
     """Get a mailing list configuration."""
     resource = {}
     if self._attribute is None:
         # Return all readable attributes.
         for attribute in ATTRIBUTES:
             value = ATTRIBUTES[attribute].get(self._mlist, attribute)
             resource[attribute] = value
     elif self._attribute not in ATTRIBUTES:
         return http.bad_request([], b"Unknown attribute: {0}".format(self._attribute))
     else:
         attribute = self._attribute
         value = ATTRIBUTES[attribute].get(self._mlist, attribute)
         resource[attribute] = value
     return http.ok([], etag(resource))

 def system(self, request, segments):
     """/<api>/system"""
     if len(segments) == 0:
         resource = dict(
             mailman_version=system.mailman_version,
             python_version=system.python_version,
             self_link=path_to('system'),
             )
     elif len(segments) > 1:
         return http.bad_request()
     elif segments[0] == 'preferences':
         return ReadOnlyPreferences(system_preferences, 'system'), []
     else:
         return http.bad_request()
     return http.ok([], etag(resource))

 def find(self, request):
     """Find a member"""
     service = getUtility(ISubscriptionService)
     validator = Validator(
         list_id=unicode,
         subscriber=unicode,
         role=enum_validator(MemberRole),
         _optional=('list_id', 'subscriber', 'role'))
     members = service.find_members(**validator(request))
     # We can't just return the _FoundMembers instance, because
     # CollectionMixins have only a GET method, which is incompatible with
     # this POSTed resource.  IOW, without doing this here, restish would
     # throw a 405 Method Not Allowed.
     resource = _FoundMembers(members)._make_collection(request)
     return http.ok([], etag(resource))

 def preferences(self, segments):
     resource = dict()
     for attr in PREFERENCES:
         # Handle this one specially.
         if attr == 'preferred_language':
             continue
         value = getattr(self._parent, attr, None)
         if value is not None:
             resource[attr] = value
     # Add the preferred language, if it's not missing.
     preferred_language = self._parent.preferred_language
     if preferred_language is not None:
         resource['preferred_language'] = preferred_language.code
     # Add the self link.
     resource['self_link'] = path_to(
         '{0}/preferences'.format(self._base_url))
     return http.ok([], etag(resource))

 def details(self, request):
     requests = IListRequests(self._mlist)
     try:
         request_id = int(self._request_id)
     except ValueError:
         return http.bad_request()
     results = requests.get_request(request_id, RequestType.held_message)
     if results is None:
         return http.not_found()
     key, data = results
     msg = getUtility(IMessageStore).get_message_by_id(key)
     resource = dict(
         key=key,
         data=data,
         msg=msg.as_string(),
         id=request_id,
         )
     return http.ok([], etag(resource))