Example #1
0
    def get(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            self.sched = self.application.scheduler
            results = job_lister(sched=self.sched,
                                 username=username,
                                 customer_name=customer_name.encode('utf-8'),
                                 uri=uri,
                                 method=method)

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                'getting schedules', '', e))

            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #2
0
    def put(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            agent_ids = self.arguments.get('agent_ids')
            new_customer = self.arguments.get('customer_name')
            if not isinstance(agent_ids, list):
                agent_ids = agent_ids.split()
            agentids_moved = []
            agentids_not_moved = []
            for agent_id in agent_ids:
                agent = AgentManager(agent_id, customer_name=customer_name)
                results = agent.change_customer(new_customer, uri, method)
                if results['http_status'] == 200:
                    agentids_moved.append(agent_id)
                else:
                    agentids_not_moved.append(agent_id)
            results['data'] = {
                'agentids_moved': agentids_moved,
                'agentids_not_moved': agentids_not_moved
            }
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                'agent_ids', 'delete agentids', e))
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
    def put(self):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            app_ids = self.arguments.get('app_ids')
            toggle = self.arguments.get('hide', 'toggle')
            results = (
                update_hidden_status(
                    username, customer_name, uri,
                    method, app_ids, toggle,
                    CustomAppsCollection
                )
            )

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            logger.exception(e)
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke(app_ids, 'toggle hidden on custom_apps', e)
            )

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
    def post(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        name = self.arguments.get('name', None)
        release_date = self.arguments.get('release_date', None)
        severity = self.arguments.get('severity', 'Optional')
        description = self.arguments.get('description', None)
        kb = self.arguments.get('kb', '')
        support_url = self.arguments.get('support_url', '')
        major_version = self.arguments.get('major_version', None)
        minor_version = self.arguments.get('minor_version', None)
        vendor_name = self.arguments.get('vendor_name', None)
        operating_system = self.arguments.get('operating_system', None)
        size = self.arguments.get('size', None)
        md5 = self.arguments.get('md5_hash', None)
        cli_options = self.arguments.get('cli_options', None)
        arch = self.arguments.get('arch', None)
        uuid = self.arguments.get('id', None)

        result = (store_package_info_in_db(
            username, customer_name, uri, method, size, md5, operating_system,
            uuid, name, severity, arch, major_version, minor_version,
            release_date, vendor_name, description, cli_options, support_url,
            kb))

        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(result, indent=4))
    def get(self):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        query = self.get_argument('query', None)
        count = int(self.get_argument('count', 30))
        offset = int(self.get_argument('offset', 0))
        status = self.get_argument('status', None)
        severity = self.get_argument('severity', None)
        sort = self.get_argument('sort', 'asc')
        sort_by = self.get_argument('sort_by', CustomAppsKey.Name)
        hidden = self.get_argument('hidden', 'false')
        if hidden == 'false':
            hidden = NO
        else:
            hidden = YES
        uri = self.request.uri
        method = self.request.method
        patches = (RetrieveCustomApps(username,
                                      customer_name,
                                      uri,
                                      method,
                                      count,
                                      offset,
                                      sort,
                                      sort_by,
                                      show_hidden=hidden))
        if not query and not severity and not status:
            results = patches.get_all_apps()

        elif not query and status and severity:
            results = patches.filter_by_status_and_sev(status, severity)

        elif severity and not query and not status:
            results = patches.filter_by_severity(severity)

        elif severity and status and query:
            results = (patches.filter_by_status_and_query_by_name_and_sev(
                query, status, severity))

        elif status and not query and not severity:
            results = (patches.filter_by_status(status))

        elif status and query:
            results = (patches.filter_by_status_and_query_by_name(
                query, status))

        elif severity and query:
            results = (patches.filter_by_sev_and_query_by_name(
                query, severity))

        elif query and not severity and not status:
            results = patches.query_by_name(query)

        else:
            results = (GenericResults(username, uri,
                                      method).incorrect_arguments())

        self.set_status(results['http_status'])
        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(results, indent=4))
Example #6
0
    def delete(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            tag_id = self.arguments.get('id', None)
            if tag_id:
                tag = TagsManager(username, customer_name, uri, method)
                results = tag.remove_tag(tag_id)

            else:
                results = (
                    GenericResults(
                        username, uri, method
                    ).incorrect_arguments()
                )

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('agentids and tag_id', 'delete agents_in_tagid', e)
            )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #7
0
    def put(self, agent_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            oper_id = self.arguments.get('operation_id')
            data = self.arguments.get('data')
            apps_to_delete = self.arguments.get('apps_to_delete', [])
            apps_to_add = self.arguments.get('apps_to_add', [])
            error = self.arguments.get('error', None)
            reboot_required = self.arguments.get('reboot_required')
            app_id = self.arguments.get('app_id')
            success = self.arguments.get('success')
            results = (AddAppResults(username, uri, method, agent_id, app_id,
                                     oper_id, reboot_required, success, data,
                                     apps_to_delete, apps_to_add, error))

            data = results.install_supported_apps(data)

            self.set_status(data['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.set_header('Content-Type', 'application/json')
            self.write(dumps(data, indent=4))
            send_notifications(username, customer_name, oper_id, agent_id)
        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                agent_id, 'install_supported_apps results', e))
            logger.exception(results)

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(dumps(results, indent=4))
    def get(self):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            results = (
                get_all_notifications(
                    username, customer_name,
                    uri, method
                )
            )
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('Get list of notifications', 'notifications', e)
            )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #9
0
 def get(self):
     username = self.get_current_user().encode('utf-8')
     customer_name = get_current_customer_name(username)
     uri = self.request.uri
     method = self.request.method
     try:
         results = (
             customer_apps_by_type_count(
                 username, customer_name,
                 uri, method
             )
         )
         self.set_status(results['http_status'])
         self.set_header('Content-Type', 'application/json')
         self.write(json.dumps(results, indent=4))
     except Exception as e:
         results = (
             GenericResults(
                 username, uri, method
             ).something_broke('widget handler', 'widgets', e)
         )
         logger.exception(results)
         self.set_status(results['http_status'])
         self.set_header('Content-Type', 'application/json')
         self.write(json.dumps(results, indent=4))
Example #10
0
    def get(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            results = None
            os_code = self.get_argument('os_code', None)
            tag_id = self.get_argument('tag_id', None)
            results = systems_hardware_details(username=username,
                                               customer_name=customer_name,
                                               os_code=os_code,
                                               tag_id=tag_id,
                                               uri=uri,
                                               method=method)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                'no stats', '', e))
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #11
0
 def get(self, tag_id):
     username = self.get_current_user().encode('utf-8')
     customer_name = get_current_customer_name(username)
     uri = self.request.uri
     method = self.request.method
     try:
         count = self.get_argument('limit', 3)
         results = (
             tag_stats_by_os(
                 username, customer_name,
                 uri, method, tag_id, count
             )
         )
         self.set_status(results['http_status'])
         self.set_header('Content-Type', 'application/json')
         self.write(json.dumps(results, indent=4))
     except Exception as e:
         results = (
             GenericResults(
                 username, uri, method
             ).something_broke('customer os stats', 'os stats', e)
         )
         logger.exception(results)
         self.set_status(results['http_status'])
         self.set_header('Content-Type', 'application/json')
         self.write(json.dumps(results, indent=4))
Example #12
0
    def get(self, tag_id):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            results = (
                get_severity_bar_chart_stats_for_tag(
                    username, customer_name,
                    uri, method, tag_id
                )
            )
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('tag severity stats', 'sev stats', e)
            )
            logger.exception(results)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #13
0
    def get(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri=self.request.uri
        method=self.request.method
        try:
            results= None
            os_code=self.get_argument('os_code', None)
            tag_id=self.get_argument('tag_id', None)
            results = systems_cpu_details(username=username, customer_name=customer_name,
                    tag_id=tag_id, os_code=os_code,
                    uri=uri, method=method
                    )
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                    GenericResults(
                        username, uri, method
                        ).something_broke('no stats', '', e)
                    )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #14
0
    def get(self, tag_id):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            status = self.get_argument('status', 'available')
            start_date = self.get_argument('start_date', None)
            end_date = self.get_argument('end_date', None)
            if start_date:
                start_date = int(start_date)
            if end_date:
                end_date = int(end_date)

            results = (get_os_apps_history_for_tag(username, customer_name,
                                                   uri, method, tag_id, status,
                                                   start_date, end_date))
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                'customer os stats', 'os stats', e))
            logger.exception(results)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #15
0
    def get(self, mouse_name):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            mouse = mouse_exists(mouse_name)
            mouse = [mouse]
            results = (
                GenericResults(
                    username, uri, method
                ).information_retrieved(mouse, len(mouse))
            )

            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke(mouse_name, 'get mouse', e)
            )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
    def post(self, app_id):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            severity = self.arguments.get('severity').capitalize()
            if severity in ValidRvSeverities:
                sev_data = ({AppsKey.RvSeverity: severity})
                update_agent_app(app_id, sev_data)
                results = (GenericResults(username, uri,
                                          method).object_updated(
                                              app_id, 'app severity',
                                              [sev_data]))
                self.set_status(results['http_status'])
                self.set_header('Content-Type', 'application/json')
                self.write(json.dumps(results, indent=4))

            else:
                results = (PackageResults(username, uri,
                                          method).invalid_severity(severity))
                self.set_status(results['http_status'])
                self.set_header('Content-Type', 'application/json')
                self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                app_id, 'update_severity', e))
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #17
0
    def post(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            mouse_name = self.arguments.get('name')
            address = self.arguments.get('address')
            customers = self.arguments.get('customers', None)
            mm = MightyMouse(username, customer_name, uri, method)
            results = mm.add(mouse_name, address, customers)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke(agent_id, '', e)
            )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #18
0
    def put(self):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            app_ids = self.arguments.get('app_ids')
            toggle = self.arguments.get('hide', 'toggle')
            results = (
                update_hidden_status(
                    username, customer_name, uri,
                    method, app_ids, toggle
                )
            )

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            logger.exception(e)
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke(app_ids, 'toggle hidden on os_apps', e)
            )

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #19
0
    def put(self, agent_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            oper_id = self.arguments.get('operation_id')
            error = self.arguments.get('error', None)
            success = self.arguments.get('success')
            results = (
                AddResults(
                    username, uri, method, agent_id,
                    oper_id, success, error
                )
            )
            results_data = results.shutdown()
            self.set_status(results_data['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(dumps(results_data, indent=4))
            send_notifications(username, customer_name, oper_id, agent_id)
        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke(agent_id, 'shutdown results', e)
            )
            logger.exception(results)

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(dumps(results, indent=4))
Example #20
0
    def delete(self, agent_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        tag_id = self.arguments.get('tag_id', None)
        uri = self.request.uri
        method = self.request.method
        tag = (
            TagsManager(
                username, customer_name,
                uri, method
            )
        )
        if tag_id:
            results = tag.remove_tag_from_agent(tag_id, agent_id)

        else:
            results = (
                GenericResults(
                    username, uri, method
                ).incorrect_arguments()
            )

        self.set_status(results['http_status'])
        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(results, indent=4))
    def get(self, tag_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            count = int(self.get_argument('count', 20))
            offset = int(self.get_argument('offset', 0))
            sort = self.get_argument('sort', 'desc')
            sort_by = self.get_argument('sort_by', OperationKey.CreatedTime)
            operations = (OperationRetriever(username, customer_name, uri,
                                             method, count, offset, sort,
                                             sort_by))

            results = operations.get_all_operations_by_tagid(tag_id)

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                'operation', 'search by oper type', e))
            logger.exception(results)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #22
0
    def get(self, agent_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            agent_queue = '[]'
            rqueue = QueueWorker({'agent_id': agent_id}, username)
            queue_exists = rqueue.exists()
            agent_queue = (process_queue_data(rqueue, queue_exists, agent_id,
                                              username, customer_name, uri,
                                              method))
            status = (AgentResults(username, uri,
                                   method).check_in(agent_id, agent_queue))
            logger.info(status)
            update_agent_status(agent_id, username, self.request.uri,
                                self.request.method)
            self.set_status(status['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(dumps(status))

        except Exception as e:
            status = (GenericResults(username, uri, method).something_broke(
                agent_id, 'check_in', e))
            logger.exception(e)
            self.set_status(status['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(dumps(status))
Example #23
0
    def get(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri=self.request.uri
        method=self.request.method
        try:
            results= None
            key=self.get_argument('key')
            query=self.get_argument('query')
            results = systems_hardware_details(username=username, customer_name=customer_name, 
                    key=key, query=query, 
                    uri=uri, method=method)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                    GenericResults(
                        username, uri, method
                        ).something_broke('no stats', '', e)
                    )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #24
0
    def get(self, tag_id):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            status = self.get_argument('status', 'available')
            start_date = self.get_argument('start_date', None)
            end_date = self.get_argument('end_date', None)
            if start_date:
                start_date = int(start_date)
            if end_date:
                end_date = int(end_date)

            results = (
                get_os_apps_history_for_tag(
                    username, customer_name,
                    uri, method, tag_id, status,
                    start_date, end_date
                )
            )
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('customer os stats', 'os stats', e)
            )
            logger.exception(results)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
    def delete(self):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            #app_ids = self.arguments.get('app_ids') The UI needs to past the options as the body not as arguments
            app_ids = self.get_arguments('app_ids')
            appids_deleted = 0
            appids_failed = 0
            for appid in app_ids:
                deleted = (delete_app_from_rv(appid, CustomAppsCollection,
                                              CustomAppsPerAgentCollection))
                if deleted:
                    appids_deleted += 1
                else:
                    appids_failed += 1

            results = (PackageResults(username, uri, method).packages_deleted(
                app_ids, appids_deleted, appids_failed))

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            logger.exception(e)
            results = (GenericResults(username, uri, method).something_broke(
                app_ids, 'failed to delete custom_apps', e))

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
    def post(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        name = self.arguments.get('name', None)
        release_date = self.arguments.get('release_date', None)
        severity = self.arguments.get('severity', 'Optional')
        description = self.arguments.get('description', None)
        kb = self.arguments.get('kb', '')
        support_url = self.arguments.get('support_url', '')
        major_version = self.arguments.get('major_version', None)
        minor_version = self.arguments.get('minor_version', None)
        vendor_name = self.arguments.get('vendor_name', None)
        operating_system = self.arguments.get('operating_system', None)
        size = self.arguments.get('size', None)
        md5 = self.arguments.get('md5_hash', None)
        cli_options = self.arguments.get('cli_options', None)
        arch = self.arguments.get('arch', None)
        uuid = self.arguments.get('id', None)

        result = (
            store_package_info_in_db(
                username, customer_name, uri, method,
                size, md5, operating_system, uuid, name,
                severity, arch, major_version, minor_version,
                release_date, vendor_name, description,
                cli_options, support_url, kb
            )
        )

        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(result, indent=4))
Example #27
0
    def get(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri=self.request.uri
        method=self.request.method
        try:
            self.sched = self.application.scheduler
            results = job_lister(
                sched=self.sched, username=username,
                customer_name=customer_name.encode('utf-8'),
                uri=uri, method=method
            )

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('getting schedules', '', e)
            )

            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #28
0
    def delete(self, jobname):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            self.sched = self.application.scheduler
            results = (remove_job(self.sched,
                                  jobname,
                                  uri=uri,
                                  method=method,
                                  customer_name=customer_name,
                                  username=username))
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                'delete schedule', '', e))

            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #29
0
    def delete(self, jobname):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri=self.request.uri
        method=self.request.method
        try:
            self.sched = self.application.scheduler
            results = (
                remove_job(
                    self.sched, jobname,
                    uri=uri,method=method,
                    customer_name=customer_name,
                    username=username
                )
            )
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('delete schedule', '', e)
            )

            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #30
0
    def post(self, agent_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            reboot = self.arguments.get('reboot', None)
            shutdown = self.arguments.get('shutdown', None)
            apps_refresh = self.arguments.get('apps_refresh', None)
            operation = (StoreOperation(username, customer_name, uri, method))
            if reboot:
                results = (operation.reboot([agent_id]))
            elif shutdown:
                results = (operation.shutdown([agent_id]))
            elif apps_refresh:
                results = (operation.apps_refresh([agent_id]))
            else:
                results = (GenericResults(username, uri,
                                          method).incorrect_arguments())

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri,
                                      method).something_broke(agent_id, '', e))
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #31
0
    def get(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            results = None
            key = self.get_argument('key')
            query = self.get_argument('query')
            results = systems_cpu_details(username=username,
                                          customer_name=customer_name,
                                          query=query,
                                          key=key,
                                          uri=uri,
                                          method=method)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (GenericResults(username, uri, method).something_broke(
                'no stats', '', e))
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
    def get(self, app_id):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        query = self.get_argument('query', None)
        count = int(self.get_argument('count', 30))
        offset = int(self.get_argument('offset', 0))
        status = self.get_argument('status', 'installed')
        uri = self.request.uri
        method = self.request.method
        agents = (RetrieveAgentsByCustomAppId(username, customer_name, app_id,
                                              uri, method, count, offset))

        if status and not query:
            results = (agents.filter_by_status(status))

        elif status and query:
            results = (agents.filter_by_status_and_query_by_name(
                query, status))

        else:
            results = (GenericResults(username, uri,
                                      method).incorrect_arguments())

        self.set_status(results['http_status'])
        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(results, indent=4))
    def delete(self, notification_id):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            notification = (
                Notifier(
                    username, customer_name,
                    uri, method
                )
            )

            results = (
                notification.delete_alerting_rule(notification_id)
            )
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('delete notification', 'notifications', e)
            )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #34
0
    def get(self, agent_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            count = int(self.get_argument('count', 20))
            offset = int(self.get_argument('offset', 0))
            sort = self.get_argument('sort', 'desc')
            sort_by = self.get_argument('sort_by', OperationKey.CreatedTime)
            operations = (
                OperationRetriever(
                    username, customer_name,
                    uri, method, count, offset,
                    sort, sort_by
                )
            )

            results = operations.get_all_operations_by_agentid(agent_id)

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('operation', 'search by oper type', e)
            )
            logger.exception(results)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #35
0
 def get(self):
     username = self.get_current_user().encode('utf-8')
     customer_name = get_current_customer_name(username)
     appid = self.get_argument('id', None)
     result = bar_chart_for_appid_by_status(app_id=appid,
                                            customer_name=customer_name)
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(result, indent=4))
Example #36
0
 def get(self):
     username = self.get_current_user().encode('utf-8')
     customer_name = get_current_customer_name(username)
     appid = self.get_argument('id', None)
     result = bar_chart_for_appid_by_status(app_id=appid,
                                           customer_name=customer_name)
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(result, indent=4))
Example #37
0
 def post(self):
     passed = False
     logged_in = False
     username = self.get_current_user()
     customer_name = get_current_customer_name(username)
     mail_host = self.get_argument('host', None)
     mail_user = self.get_argument('user', None)
     mail_password = self.get_argument('password', None)
     mail_port = self.get_argument('port', 25)
     from_email = self.get_argument('from_email', None)
     to_email = self.get_arguments('to_email')
     is_tls = self.get_argument('is_tls', False)
     is_ssl = self.get_argument('is_ssl', False)
     if is_tls:
         is_tls = return_bool(is_tls)
     if is_ssl:
         is_ssl = return_bool(is_ssl)
     if mail_host and mail_user and mail_password and \
             mail_port and from_email and len(to_email) >0:
         create_or_modify_mail_config(
             modifying_username=username, customer_name=customer_name,
             server=mail_host, username=mail_user,
             password=mail_password, port=mail_port,
             is_tls=is_tls, is_ssl=is_ssl,
             from_email=from_email, to_email=to_email
         )
         mail = MailClient(customer_name)
         mail.connect()
         if mail.logged_in:
             message = '%s - Valid Mail Settings' % (username)
             logger.info(message)
             result = {
                     'pass': True,
                     'message': 'Valid Mail Settings'
                     }
         elif not mail.logged_in:
             message = '%s - Incorrect Authentication Settings' % (username)
             logger.error(message)
             result = {
                     'pass': False,
                     'message': 'Incorrect Authentication Settings'
                     }
         elif not mail.connnected:
             message = '%s - Invalid Connection Settings' % (username)
             logger.error(message)
             result = {
                     'pass': False,
                     'message': 'Invalid Connection Settings'
                     }
     else:
         message = '%s - Incorrect Parameters Passed' % (username)
         logger.error(message)
         result = {
             'pass': False,
             'message': 'Incorrect Parameters Passed'
             }
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(result, indent=4))
Example #38
0
    def put(self, agent_id):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            displayname = self.arguments.get('display_name', None)
            hostname = self.arguments.get('hostname', None)
            prod_level = self.arguments.get('production_level', None)
            new_customer = self.arguments.get('customer_name', None)
            agent = AgentManager(agent_id, customer_name=customer_name)

            if (displayname and not hostname and not
                    prod_level and not new_customer):
                results = agent.displayname_changer(displayname, uri, method)

            elif (hostname and not prod_level and not displayname
                    and not new_customer):
                results = agent.hostname_changer(hostname, uri, method)

            elif (prod_level and not hostname and not displayname
                    and not new_customer):
                results = agent.production_state_changer(prod_level, uri, method)

            elif prod_level and hostname and displayname and not new_customer:
                agent_data = {
                    'host_name': hostname,
                    'production_level': prod_level,
                    'display_name': displayname
                }
                results = agent.update_fields(agent_data, uri, method)

            elif (new_customer and not prod_level and not hostname
                and not displayname):
                results = agent.change_customer(new_customer, uri, method)

            else:
                results = (
                    GenericResults(
                        username, uri, method
                    ).incorrect_arguments()
                )

            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke(agent_id, 'modify agent', e)
            )
            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #39
0
 def get(self, tag_id):
     username = self.get_current_user()
     customer_name = get_current_customer_name(username)
     uri = self.request.uri
     method = self.request.method
     tag = TagSearcher(username, customer_name, uri, method)
     results = tag.get_tag(tag_id)
     self.set_status(results['http_status'])
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(results, indent=4))
 def get(self):
     username = self.get_current_user().encode('utf-8')
     customer_name = get_current_customer_name(username)
     result = (
         get_valid_fields(
             customer_name=customer_name
         )
     )
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(result, indent=4))
 def get(self):
     username = self.get_current_user()
     customer_name = get_current_customer_name(username)
     uri = self.request.uri
     method = self.request.method
     data = {"uuid": gen_uuid()}
     results = (GenericResults(username, uri,
                               method).information_retrieved(data, 0))
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(results, indent=4))
 def get(self):
     username = self.get_current_user()
     customer_name = get_current_customer_name(username)
     uri = self.request.uri
     method = self.request.method
     data = {"uuid": gen_uuid()}
     results = (
         GenericResults(
             username, uri, method
         ).information_retrieved(data, 0)
     )
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(results, indent=4))
Example #43
0
    def post(self):
        username = self.get_current_user()
        customer_name = get_current_customer_name(username)
        uri = self.request.uri
        method = self.request.method
        try:
            result = None
            sched = self.application.scheduler
            uri = self.request.uri
            method = self.request.method
            operation = self.arguments.get('operation', None)
            pkg_type = self.arguments.get('pkg_type', None)
            severity = self.arguments.get('severity', None)
            jobname = self.arguments.get('jobname', None)
            node_ids = self.arguments.get('nodes', None)
            tag_ids = self.arguments.get('tags', None)
            all_tags=self.arguments.get('all_tags', False)
            all_agents=self.arguments.get('all_agents', False)
            epoch_time = self.arguments.get('epoch_time')
            every = self.arguments.get('every', None)
            custom = self.arguments.get('custom', None)


            if operation and jobname:
                results = (
                    add_monthly_recurrent(
                        sched, agent_ids=node_ids,all_agents=all_agents,
                        all_tags=all_tags,tag_ids=tag_ids, severity=severity,
                        pkg_type=pkg_type,operation=operation, 
                        name=jobname, epoch_time= epoch_time,
                        custom = custom, every = every,
                        customer_name=customer_name,
                        username=username, uri=uri, method=method
                    )
                )
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))

        except Exception as e:
            results = (
                GenericResults(
                    username, uri, method
                ).something_broke('add monthly recurrent schedule', '', e)
            )

            logger.exception(e)
            self.set_status(results['http_status'])
            self.set_header('Content-Type', 'application/json')
            self.write(json.dumps(results, indent=4))
Example #44
0
    def put(self, agent_id):
        try:
            username = self.get_current_user()
            customer_name = get_current_customer_name(username)
            uri = self.request.uri
            method = self.request.method
            rebooted = self.arguments.get(AgentKey.Rebooted)
            plugins = self.arguments.get(AgentKey.Plugins)
            system_info = self.arguments.get(AgentKey.SystemInfo)
            hardware = self.arguments.get(AgentKey.Hardware)
            logger.info(
                'data received on startup: %s' % self.request.body
            )
            agent_data = (
                update_agent(
                    username, customer_name,
                    uri, method,
                    agent_id, system_info,
                    hardware, rebooted
                )
            )
            agent_data.pop('data')
            agent_data['data'] = []
            logger.info(agent_data)
            self.set_status(agent_data['http_status'])

            if agent_data['http_status'] == 200:
                if 'rv' in plugins:
                    RvHandOff(
                        username, customer_name, uri, method,
                        agent_id, plugins['rv']['data'],
                        oper_type='updates_applications'
                    )

                if 'ra' in plugins:
                    RaHandoff.startup(agent_id, plugins['ra'])

            self.set_header('Content-Type', 'application/json')
            self.write(dumps(agent_data))

        except Exception as e:
            status = (
                GenericResults(
                    username, uri, method
                ).something_broke(agent_id, 'startup', e)
            )

            logger.exception(status['message'])
            self.write(dumps(status))
Example #45
0
    def get(self, tag_id):
        username = self.get_current_user().encode('utf-8')
        customer_name = get_current_customer_name(username)
        available = self.get_argument('available', True)
        if not isinstance(available, bool):
            available = return_bool(available)

        results = (
            get_avail_over_time(
                tag_id=tag_id, available=available,
                customer_name=customer_name
            )
        )
        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(results, indent=4))
 def get(self, app_id):
     username = self.get_current_user().encode('utf-8')
     customer_name = get_current_customer_name(username)
     uri = self.request.uri
     method = self.request.method
     patches = (
         RetrieveCustomAppsByAppId(
             username, customer_name, app_id,
             uri, method
         )
     )
     results = patches.get_by_app_id(stats=True)
     self.set_status(results['http_status'])
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(results, indent=4))
Example #47
0
    def post(self):

        current_user = self.get_current_user()
        current_customer = get_current_customer_name(current_user)
        body = json.loads(self.request.body)
        password = body.get('password')

        results = ra_settings.save_rd_password(
            password=password,
            user=current_user,
            customer=current_customer
        )

        self.set_header('Content-Type', 'application/json')
        self.write(json.dumps(results, indent=4))
Example #48
0
 def get(self):
     username = self.get_current_user()
     customer_name = get_current_customer_name(username)
     mail = MailClient(customer_name)
     result = {
         'host': mail.server,
         'username': mail.username,
         'port': mail.port,
         'from_email': mail.from_email,
         'to_email': mail.to_email,
         'is_tls': mail.is_tls,
         'is_ssl': mail.is_ssl
         }
  
     self.set_header('Content-Type', 'application/json')
     self.write(json.dumps(result, indent=4))