Python Request.post方法代码示例

# 需要导入模块: from request import Request [as 别名]
# 或者: from request.Request import post [as 别名]
class Connection:

	def __init__(self, host, public_key, private_key):
		self.host = host
		self.public_key = public_key
		self.private_key = private_key
		self.auth = Auth(public_key, private_key)
		self.request = Request(self.host, self.auth)

	def add_user(self):
		return self.request.post('/users/', {})

	def delete_user(self, user):
		return self.request.delete('/users/' + user)

	def get_streams(self):
		return self.request.get('/streams/')

	def add_stream(self, stream):
		return self.request.post('/streams/', {'stream': stream})

	def delete_stream(self, stream):
		return self.request.delete('/streams/' + stream + '/')

	def get_sources(self, stream):
		return self.request.get('/streams/' + stream + '/')

	def add_source(self, stream, source):
		return self.request.post('/streams/' + stream + '/', {'source': source})

	def delete_source(self, stream, source):
		return self.request.delete('/streams/' + stream + '/' + source + '/')

# 需要导入模块: from request import Request [as 别名]
# 或者: from request.Request import post [as 别名]
    def create_file_task(self, task_id, sample_path, sensor_filename, timeout,
                         priority, memory, clock, enforce_timeout,
                         custom_options):
        """Submit the given file to the cuckoo api in order to create a
        new task for it.

        Keyword arguments:
            task_id -- the manually specified id for the task
            sample_path -- the path to the sample file
            sensor_filename -- the name of the sensor file
            timeout -- timeout for the task
            priority -- priority to assign to the task (1-3)
            memory -- enable the creation of a full memory dump of the
                      analysis machine
            clock -- sets the vm clock for this task to the given value
            enforce_timeout -- enable to enforce the execution for the full
                               timeout value
            custom_options --  custom option parameters that will be appended
                               to the option parameter of the cuckoo api

        """
        api_url = self.server_url + self.METHOD_CREATE_FILE_TASK

        if sensor_filename:
            options_params = "sensor=" + sensor_filename
        else:
            options_params = ""

        if custom_options:
            options_params = options_params + ", " + custom_options

        post_params = {
            'custom': task_id,
            'options': options_params,
            'timeout': timeout,
            'priority': priority,
            'memory': memory,
            'clock': clock,
            'enforce_timeout': enforce_timeout
        }

        files = {'file': open(sample_path, 'rb')}
        request = Request(api_url)

        log.info("Request to " + api_url + " with params " + str(post_params))
        try:
            response = request.post(post_params, files)
        except HTTPError, e:
            log.error("Error in create_file_task: " + str(e))
            raise CuckooError(str(e))

# 需要导入模块: from request import Request [as 别名]
# 或者: from request.Request import post [as 别名]
class Server(BaseObject):
    """This Object handles all Server-based interactions"""
    action = {
        'info': '%s/server',
        'disconnect': '%s/disconnect'
    }

    def __init__(self, url, username, password):
        super(Server, self).__init__(data=None)

        self.url = url
        self.username = username
        self.password = password
        self.request = Request(self.username, self.password)

    def info(self):
        """
        This method queries the server for all of the
        information related to it 
        """
        url = self.action['info'] % (self.url)
        response, content = self.request.get(url=url)

        if response.status == 200:
            self.data = json.loads(content)
            return
        else:
            raise CompassException(content)

        return self

    def disconnect(self):
        """Sends a disconnect request to the server"""
        url = self.action['disconnect'] % (self.url)
        self.request.get(url)

    def database(self, name, credentials=ADMIN, create=False, storage='memory'):
        """Sends a request the server for a database
        will both add new and query existing databases.
        
        Returns a Datase object
        """
        if create:
            url = Database.action['post'] % (self.url, name, storage)
            response, content = self.request.post(url=url, data=None)

            if response.status == 200:
                return self.database(name=name, credentials=ADMIN)
            else:
                raise CompassException(content)
        else:
            url = Database.action['get'] % (self.url, name)
            user, password = credentials
            request = Request(user, password)
            response, content = request.get(url=url)

            if response.status == 200:
                data = json.loads(content)
                return Database(self.url, name=name,
                                credentials=credentials, data=data).connect()
            else:
                raise CompassException(content)

# 需要导入模块: from request import Request [as 别名]
# 或者: from request.Request import post [as 别名]
class Database(BaseObject):
    """Database object"""
    action = {
        'connect': '%s/connect/%s',
        'get': '%s/database/%s',
        'post': '%s/database/%s/%s',
        'query': '%s/command/%s/%s/%s',
        'cluster': '%s/cluster/%s/%s'
    }

    def __init__(self, url, name, credentials, lang='sql', data=None):
        super(Database, self).__init__(data=None)

        self.url = url
        self.lang = lang
        self.name = name
        self.credentials = credentials
        self.request = Request(username=credentials[0],
                               password=credentials[1])

        if data is None:
            self.connect()
        else: 
            self.data = data

    def reload(self, callback=None):
        """This method will repopulate the 
        data property of for the Database object
        """
        url = self.action['get'] % (self.url, self.name)        
        response, content = self.request.get(url)

        if response.status == 200:
            self.data = json.loads(content)

            if callback is not None and hasattr(callback, '__call__'):
                callback()
        else:
            raise CompassException(content)

    def connect(self):
        """Creats a connection to the database"""
        url = self.action['connect'] % (self.url, self.name)        
        response, content = self.request.get(url)

        if response.status == 200:
            self.data = json.loads(content)
        else:
            raise CompassException(content)

        return self

    def cluster(self, class_name):
        """Queries the server for a Cluster object"""
        url = Cluster.action['get'] % (self.url, self.name, class_name)
        response, content = self.request.get(url)

        if response.status == 200:
            return Cluster(database=self, data=json.loads(content))
        else:
            raise CompassException(content)

    def klass(self, name, limit=20, create=False):
        """Sends a request the server for class information
        will both add new and query existing classes.
        
        Returns a Klass object
        """
        if create:
            url = Klass.action['post'] % (self.url, self.name, name)
            response, content = self.request.post(url, data={})

            if response.status == 201:
                return self.klass(name=name)
            else: 
                raise CompassException(content)
        else:
            url = Klass.action['get'] % (self.url, self.name, name, limit)
            response, content = self.request.get(url)

            if response.status == 200:
                data = json.loads(content)

                if data.has_key('result'):
                    data = data['result']
                else:
                    data = None;

                return Klass(database=self, name=name,
                    documents=data)
            else:
                raise CompassException(content)

    def query(self, query, klass=None):
        """Sends a reqeust to the server based on a query"""
        query = urllib.quote(query)
        url = self.action['query'] % (self.url, self.name, self.lang, query)
        response, content = self.request.post(url, data={})

        if response.status == 200:
#.........这里部分代码省略.........

# 需要导入模块: from request import Request [as 别名]
# 或者: from request.Request import post [as 别名]
 def create(self, **kwargs):
     return Request.post("breweries.json", kwargs)

# 需要导入模块: from request import Request [as 别名]
# 或者: from request.Request import post [as 别名]
 def auth(self, **kwargs):
     return Request.post("users/auth", kwargs)