#!/usr/bin/env python
# By Steve 'Ashcrow' Milner

import nmap

try:
    from multiprocessing import Process, Queue
except ImportError:
    # For pre 2.6 releases
    from threading import Thread as Process
    from Queue import Queue


class NmapProcess(object):
    """
    Process scans in a non-blocking way.
    """

    def __init__(self, host):
        """
        Creates an instance.

        :Parameters:
           - `host`: host to scan
        """
        self.__host = host
        self.__queue = Queue()
        self.__nm = nmap.PortScanner()
        self.__process = None

    def scan(self, ports=None, arguments='-sV', callback=None):
        """
        Starts the scan taking the same input as nmap scan except the host.

        :Parameters:
           - `ports`: ports to scan
           - `arguments` arguments for nmap
           - `callback`: optional callback to execute when results are available
        """

        def scan_process(ports, arguments, callback=None):
            self.__nm.scan(self.__host, ports, arguments)
            self.__queue.put(self.__nm)
            if callback and callable(callback):
                callback(self.__nm)

        self.__process = Process(
            target=scan_process, args=(ports, arguments, callback))
        self.__process.daemon = True
        self.__process.start()

    def __get_results(self):
        """
        Returns results if they are available, else None.
        """
        if self.__queue.empty():
            return None
        return self.__queue.get()[self.__host]

    def __del__(self):
        """
        Clean up.
        """
        self.__process.join()

    # Properties
    results = property(__get_results)
    results_available = property(lambda s: not s.__process.is_alive())


if __name__ == '__main__':
    n = NmapProcess('127.0.0.1')

    def p(s):
        print("From Callback: " + str(s['127.0.0.1']))
    n.scan(arguments="-sV -T4 -A", callback=p)
    # Do stuff here ...
    from time import sleep
    while not n.results_available:
        print("Waiting ...")
        sleep(3)
    print("From property: " + str(n.results))

class _MongoSaveable(object):
    """
    Simple mongodb saveable object. Saves all attributes.

    You can force saves using a shortcut like so:
       >>> save = lambda s: s.__mongo_save__(COLLECTION)
       >>> save(my_instance)
    """

    _id = None
    _dirty = False

    def __setattr__(self, name, value):
        """
        TRY TO CATCH ME RIDN DIRTY *money money money*

        :Parameters:
           - `name`: key name
           - `value`: data to store
        """
        self.__dict__['_dirty'] = True
        self.__dict__[name] = value

    def __mongo_save__(self, collection):
       """
       Insert or Update data.

       :Parameters:
          - `collection`: the collection to associate with
       """
       if not self._dirty:
           return None
       result = {}
       for x in dir(self):
           if (not x.startswith('_') and
               not callable(getattr(self, x)) and
               x not in ("id", "dirty")):
               result[x] = getattr(self, x)
       if self._id:
           collection.save(result)
       else:
           saved_data = collection.find_one(result)
           if saved_data:
               self._id = saved_data["_id"]
           else:
               self._id = collection.insert(result)
       self._dirty = False

    dirty = property(lambda s: s._dirty)
    id = property(lambda s: s._id)

# PSUEDO EXAMPLE!!!!

import pymongo

from myapp import Example

# Connection stuff
DB = pymongo.Connection().my_database
COLLECTION = DB.my_collection

# Save shortcut
save = lambda s: s.__mongo_save__(COLLECTION)


class DataExample(Example, _MongoSaveable):
    def __init__(self, weight):
        self.weight = weight

    def calculate_status(self):
        if self.weight > 175:
            self.status = "lose wight"
        else:
            self.status = "doin fine"

ex = DataExample(150)
ex.calculate_status()
save(ex)
print ex.id # 4b9c6398bdcf5f4053000000
ex.goal_weight = 160
save(ex) 
print ex.id # 4b9c6398bdcf5f4053000000

--- bindings/python/mongoose.py	2010-03-10 20:07:53.735407453 -0500
+++ bindings/python/mongoose.py	2010-03-10 20:09:08.935760549 -0500
@@ -110,7 +110,8 @@
 
 	def __init__(self, **kwargs):
 		dll_extension = os.name == 'nt' and 'dll' or 'so'
-		self.dll = ctypes.CDLL('_mongoose.%s' % dll_extension)
+		from distutils.sysconfig import get_python_lib
+		self.dll = ctypes.CDLL(get_python_lib(1) + '/_mongoose.%s' % dll_extension)
 		start = self.dll.mg_start
 		self.ctx = ctypes.c_voidp(self.dll.mg_start()).value
 		self.version = ctypes.c_char_p(self.dll.mg_version()).value

# sitearch for others (remove the unneeded one)
%{!?python_sitearch: %global python_sitearch %(%{__python} -c "from distutils.sysconfig import get_python_lib; print(get_python_lib(1))")}


Name:           mongoose
Version:        2.8
Release:        1%{?dist}
Summary:        Simple and easy to use web server

Group:          System Environment/Daemons
License:        MIT
URL:            http://code.google.com/p/mongoose/
Source0:        http://mongoose.googlecode.com/files/%{name}-%{version}.tgz
Patch0:         mongoose-site-location.patch
BuildRoot:      %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)


%description
Mongoose is an easy to use web server. It can be embedded into
existing application to provide a web interface to it.


%package python
Summary:       Python bindings for the mongoose web server
Requires:      mongoose


%description python
Mongoose is an easy to use web server. It can be embedded into
existing application to provide a web interface to it. This
package includes the bindings for the Python programming language.


%package devel
Summary:       Development files for the mongoose web server
BuildArch:     noarch


%description devel
Mongoose is an easy to use web server. It can be embedded into
existing application to provide a web interface to it. This
package includes the development files.


%prep
%setup -qn %{name}
%patch0


%build
make %{?_smp_mflags} linux


%install
rm -rf $RPM_BUILD_ROOT
# Install the base
mkdir -p $RPM_BUILD_ROOT/%{_bindir}
mkdir -p $RPM_BUILD_ROOT/%{_mandir}/man1/
cp %{name} $RPM_BUILD_ROOT/%{_bindir}
cp %{name}.1 $RPM_BUILD_ROOT/%{_mandir}/man1/

# Install the python bindings
mkdir -p $RPM_BUILD_ROOT/%{python_sitearch}
cp bindings/python/mongoose.py _%{name}.so $RPM_BUILD_ROOT/%{python_sitearch}

# Install the development files
mkdir -p $RPM_BUILD_ROOT/%{_includedir}/%{name}/
cp %{name}.h $RPM_BUILD_ROOT/%{_includedir}/%{name}/


%clean
rm -rf $RPM_BUILD_ROOT


%files
%defattr(-,root,root,-)
%{_bindir}/%{name}
%{_mandir}/man1/%{name}.1.gz


%files python
%defattr(-,root,root,-)
%{python_sitearch}/_%{name}.so
%{python_sitearch}/%{name}.py*


%files devel
%defattr(-,root,root,-)
%{_includedir}/%{name}/


%changelog
* Wed Mar 10 2010 Steve 'Ashcrow' Milner <me@stevemilner.org> 2.8-1
- Initial spec