Rulebooks can be a bit of a buzzkill, but as the food delivery company matured, it realized it needed to go back to basics and bring its codes up to date, explains brand director Emily Somers.

Why Deliveroo did the unsexy job of updating its brand guidelines

A traditional Sunday roast dinner was always seen as the meal of the week but costs have risen hitting many families

How inflation has hit the Sunday roast - with just two things cheaper than a year ago

Getir is maintaining their U.S. operation, but incurring roughly $100 million per month.

Getir bets big on the U.S. even as it bleeds cash

Roast dinner is a family favourite across the UK but from the Yorkshire puddings to roast potatoes, how much does it cost to make?

How much does a Sunday Roast cost to cook at home?

A Sunday roast dinner is a family favourite across the UK but from the Yorkshire puddings to roast potatoes, how much does it cost to make?

How much does a Sunday roast cost to cook at home?

The grocery delivery service, Getir, has answered just that question by comparing the prices of traditional roast dinner essentials from August 2022 to August 2023. Getir has reported that the cost of a simple roast dinner for a family of four (which ...

Getir

getir

Quick Overview of the Market Over the past three years, we have all witnessed the remarkable growth of the grocery delivery industry. Just five to six years ago, the sector was vastly different, characterized by longer delivery times, limited time slots, few service providers, and issues with product and delivery quality. However, a , which I recall discussing with friends during the launch of Yandex.Lavka, a service that promised to deliver groceries in a mere 15 minutes. revolution emerged around 2019 Following that, the COVID pandemic took hold in 2020, and investments flowed like a river, resulting in the enormous development of the industry. Nonetheless, the landscape for q-commerce startups took . Factors such as the tightening of monetary policy, the gradual resolution of the pandemic, and the global economic crisis triggered by Russia's invasion of Ukraine led to a decline in investor enthusiasm. a turn for the worse in 2022 As a result, 2022 became a year of widespread disappointment: most businesses faced negative margins, growth figures proved to be heavily reliant on lockdowns, and traditional retailers accelerated their own online channel development. numerous online market players exited the industry, were acquired by larger competitors, or had to downsize and withdraw from less promising markets: Consequently, In 2021, Gorillas was considered one of the most promising players but was acquired by Getir in 2022. Getir had to let go of 14% of its workforce and abandon aggressive expansion strategies. UK-based Jiffy shifted its focus from dark store operations to offering software solutions. Yango Deli opted to shut down its operations in London and Paris (however, operations in CIS countries kept growing profitably). The majority of American Q-commerce companies, such as Fridge No More, Food Rocket, and Buyk exited the market due to a lack of financing. Additionally, 2022 marked a year when European governments took a keen interest in the development of and implemented stringent regulations, making it increasingly difficult for these ventures to operate. dark store businesses For instance, Barcelona completely prohibited the dark store format, while Amsterdam and Rotterdam imposed strict rules governing the operations of such establishments. Consequently, it appears that merely offering 15-minute delivery times no longer surprises the audience and is no longer sufficient for success in the Q-commerce sector. To survive and secure a more significant presence in the grocery retail market, these businesses must evolve and substantially improve their efficiency. The question remains, however: how can they achieve this? In this article, I will not present any detailed insights on how to derive some model or how to structure an operational process but rather share my strategic understanding of efficiency and how it is deeply interconnected with growth. Efficiency Basics Here, I would like to introduce my personal view of the problem. If you do not agree with it, I would greatly enjoy having a discussion and hearing your comments. First, let's clarify what efficiency entails. In simplified terms, there are two primary dimensions that investors and company managers typically prioritize: growth and unit economics. While customer service quality, employee satisfaction, and ESG factors are also crucial, they primarily serve as the foundation for success in growth and unit economics. Figure: What is efficiency in terms of growth and unit economics? “ Enhanced efficiency signifies that the company has achieved a more favorable balance between growth and unit economics compared to its previous state. Capitalizing on opportunities: A company cannot attain higher growth without compromising unit economics, or vice versa.” Examples: Reduction in write-offs through improved assortment and supply chain management - a direct positive impact on unit economics without significantly affecting sales Increasing the Infull percentage (the proportion of orders delivered with all requested items) - a clear influence on growth due to enhanced customer satisfaction without an increase in costs . Navigating trade-offs: “The company possesses a clear understanding of the trade-offs between growth and unit economics, including the impact of various levers (such as delivery fees, pricing, availability, etc.) on their target metrics” Furthermore, the current settings of these parameters align with the company's overarching objectives, whether focused on growth or unit economics. Examples: Raising the delivery fee is an action that typically has a strong negative effect on sales but significantly improves unit economics due to an increased average bill and delivery fees. Discounts for new customers have a direct positive impact on customer acquisition, accompanied by a considerable negative effect on unit economics. Capitalizing on Opportunities Quick Commerce has recently emerged, with a primary focus on expansion, which has led many companies in the sector to struggle with optimizing internal processes. Examples: A client is unable to complete an order as payment is not being accepted or a client is unable to change the account phone number, which is causing difficulties for a courier (those are the issues I am facing with Getir in Istanbul). Product: Replenishments are primarily manual and non-digitalized, which leads to larger overheads due to the necessity to maintain large supply chain departments, increased write-offs, and overwhelming stores with excessive stock. Store Supply Chain: Order picking is carried out manually without the use of barcode readers. Moreover, the in-store layout lacks digitalization, resulting in SKUs not being assigned to specific shelves. Order Picking: Order dispatch is done manually or based on a FIFO approach. This leads to inefficient routing, inability for orders batching, and low OpH (orders per hour). Order Delivery: When done effectively, optimization can yield substantial improvements in overall performance. However different the markets and companies might be, gaining efficiency on this step should imply the following: The enlisted tools and approaches are not exhaustive and will be detailed in separate articles on the matter. Nonetheless, it's crucial to acknowledge that the 80-20 rule frequently plays a role in this scenario: seizing low-hanging fruits can considerably improve efficiency, whereas tackling the remaining 20% might demand significant resources and effort. This is why, at a certain stage of development, enhancing efficiency is primarily driven by skillfully navigating trade-offs. Navigating Trade-Offs Capitalizing on opportunities can be challenging, but navigating trade-offs is often more complex and basically implies quantifying the business: Assessing the impacts of various levers on business performance in terms of growth and unit economics. A company must identify its primary levers and understand the current exchange rate between growth and unit economics for different geographies and types of business. In other words, to successfully navigate the trade-off, it needs to be able to answer the question: “If I change this particular lever (for example: delivery fee), how many additional orders will I get in this particular geography vs. how much money will I lose (due to an average bill and delivery fee drop in this case)?” Here is a non-exhaustive list of potential levers that can be implemented: Delivery Fee & Minimal Basket Delivery Time Pricing Level Discounts for New Customers The exchange rate (elasticity at each point) should be assessed using AB tests or other identification methods and then aligned with the company's strategic goals at the time. If a company has a target margin and is currently focused primarily on growth, an appropriate combination of instruments should be identified. For example, if reducing the delivery fee in one city and decreasing delivery time in another promises the largest impact on growth with the least effect on margins, this is the strategy that should be implemented. Efficiency and Growth While improving business efficiency, a company needs to understand that the target margin and the composition of the audience are highly interconnected: Targeting specific margins directly defines the income level of your target audience: Decisions such as raising prices or delivery fees can lead to the churn of lower-income users and their migration to competitors. At the same time, being a premium service might imply significantly higher margins, as high-income users generally exhibit better unit economics, as they are less sensitive to price and fee increases and tend to shop with higher average bills and superior commercial margins. Consequently, expanding the target audience, which is essential for boosting orders, primarily hinges on the overall efficiency of business processes: A company with minimal write-offs can avoid substantially raising delivery fees, which in turn helps maintain a broader range of income levels within the target audience. Still, the level of demand and the size of the target audience within each range of target margin depends mostly on the value of the client proposition, which, in this notation, defines the exchange rate and the elasticity of demand to the changes in target margin. Companies with higher shopping costs need to provide a unique and compelling offering to ensure that even affluent customers remain loyal. If a business is more expensive but offers no added benefits compared to competitors, there is no incentive for customers to shop there. While it may seem obvious, it appears that this concept has not been fully leveraged by existing market players. Most of the market players I have tried (with the exception of Yango Deli) currently offer nothing more than super-fast delivery to their customers, as their assortment mostly mirrors that of local grocery shops without any unique categories such as Ready-to-Eat or Hot Coffee. This lack of differentiation places the existing players in an even more challenging position when it comes to navigating the trade-off between future growth and unit economics. Sources: https://techcrunch.com/2022/05/25/getir-the-12b-instant-delivery-startup-plans-to-axe-14-of-staff-globally-and-cut-aggressive-expansion-plans/ https://techcrunch.com/2022/05/25/getir-the-12b-instant-delivery-startup-plans-to-axe-14-of-staff-globally-and-cut-aggressive-expansion-plans/ https://www.pwc.co.uk/industries/retail-consumer/insights/q-commerce-success-not-matter-time.html

Efficiency in the Q-Commerce Business: The strategic Overview

Infinite code smells! We see several symptoms and situations that make us doubt the quality of our development. Let's look at some possible solutions. Most of these smells are just hints of something that might be wrong. They are not rigid rules. Previous Code Smells Part I Part II Part III Part IV Part V Part VI Part VII Part VIII Part IX Part X Part XI Part XII Part XIII Part XIV Let's continue... Code Smell 71 - Magic Floats Disguised as Decimals TL;DR Don't trust numbers on immature languages like JavaScript. Problems Violation Principle of Least Surprise Accidental Complexity Wrong decimal representations. Solutions Choose Mature Languages. Represent . Decimals with Decimals Sample Code Wrong console.log(0.2 + 0.1) 
// 0.30000000000000004

//We are adding two decimal numbers
// 2/10  +  1/10 
// Result should be 3/10 as we learnt at school Right class Decimal {
  constructor(numerator) {
    this.numerator = numerator;    
  }
   plus(anotherDecimal) {
      return new Decimal(this.numerator + anotherDecimal.numerator);
  }
   toString() {
      return "0." + this.numerator;
   }}     
  
console.log((new Decimal(2).plus(new Decimal(1))).toString());
// 0.3

//We can represent the numbers with a Decimal class (storing only the numerator)
//or with a generic Fraction class (storing both the numerator and denominator) Detection Since this is a language feature, it is difficult to detect. We can ask our linters to prevent us from manipulating numbers this way. Tags JavaScript Premature Optimization Conclusion My first programming language was 's basic back in 1985. Commodore 64 I was very surprised to discover that 1+1+1 was not always 3. Then they introduced integer types. JavaScript is 30 years younger, and it has the same immaturity problems. More info Here is the technical (and accidental) explanation: https://blog.pankajtanwar.in/do-you-know-01-02-03-in-javascript-here-is-why Please, don't argue telling this is fine and expected since this is the binary representation. These numbers are decimals, we should represent them as decimals. If you think representing them as floats is a great performance improvement, you are wrong. Premature optimization is the root of all evil. Floating Point Standard - 83 pages The purpose of computing is insight, not numbers - Richard Hamming Code Smell 72 - Return Codes APIs, Return codes, C Programming Language, We've all been there. TL;DR: Don't return codes to yourself. Raise Exceptions. Problems IFs Code Polluting Outdated documentation Coupling to accidental codes. Functional logic polluted. Solutions Change Ids and return Generic Exceptions. Distinguish Happy Path from Exception Path. Sample Code Wrong function createSomething(arguments) {
    //Magic Creation
    success = false; //we failed

    //We failed to create
    if (!success) {
        return {
            object: null,
            errorCode: 403,
            errorDescription: 'We didnt have permddtttttttttission to create...'
        };
    }

    return {
        object: createdObject,
        errorCode: 400,
        errorDescription: ''
    };
}

var myObject = createSomething('argument');
if (myObject.errorCode != 400) {
    console.log(myObject.errorCode + ' ' + myObject.errorDescription)
}
//but myObject does not hold My Object but an implementative
//and accidental array 
//from now on me need to remember this Right function createSomething(arguments) {
    //Magic Creation
    success = false; //we failed

    //We failed to create
    if (!success) {
        throw new Error('We didnt have permission to create...');
    }

    return createdObject;
}

try {
    var myObject = createSomething('argument');
    //no IFS, just happy path
} catch (exception) {
    //deal with it!
    console.log(exception.message);
}
// myObject holds my expected object Detection We can teach our linters to find patterns of integer and strings returns coupled with ifs and return checking. Tags Exceptions Conclusion Ids and codes are external identifiers. They are useful when you need to interact with an external system (for example an API Rest). We should not use them on our own systems and our own internal APIs. Create and raise generic exceptions. Only create specific exceptions if you are ready to handle them, and they have specialized behavior. Don't create Exceptions. anemic Avoid favoring return codes. immature and premature optimized languages More info https://hackernoon.com/how-to-get-rid-of-annoying-ifs-forever-zuh3zlo http://nicolecarpenter.github.io/2016/03/15/clean-code-chapter-7-error-handling.html Error handling is important, but if it obscures logic, it’s wrong - Robert Martin Code Smell 73 - Exceptions for Expected Cases Exceptions are handy Gotos and flags. Let's abuse them. TL;DR: Do not use exceptions for flow control. Problems Readability Principle of least astonishment Violation. Solutions Use Exceptions just for unexpected situations. Exceptions handle . Read the contract. contract violations Sample Code Wrong try {
	for (int i = 0;; i++)
		array[i]++;
	} catch (ArrayIndexOutOfBoundsException e) {}

//Endless loop without end condition Right for (int index = 0; index < array.length; index++)
		array[index]++;

//index < array.length breaks execution Detection This is a semantic smell. Unless we use machine learning linters it will be very difficult to find the mistakes. Tags Readability Conclusion Exceptions are handy, and we should definitively use them instead of returning codes. The boundary between correct usage and wrong usage is blur like so many design principles. Relations Code Smell 72 - Return Codes More info Don't use exceptions for flow control Java Zone Stack Exchange Stack Overflow When debugging, novices insert corrective code; experts remove defective code - Richard Pattis Code Smell 74 - Empty Lines Breaking the code to favor readability asks for refactor. TL;DR Don't add empty lines to your methods. Extract them! Problems Readability Kiss Low Reuse Solutions Extract Method Refactor Remove unneeded lines. Sample Code Wrong <?

function translateFile() {
    $this->buildFilename();
    $this->readFile();
    $this->assertFileContentsAreOk();
    //A lot of lines more
    
    //Empty space to pause definition    
    $this->translateHiperLinks();
    $this->translateMetadata();
    $this->translatePlainText();
    
    //Yet Another empty space
    $this->generateStats();
    $this->saveFileContents();
    //A lot of more lines
} Right <?

function translateFile() {
    $this->readFileToMemoy();
    $this->translateContents();
    $this->saveFileContents();  
} Detection This is a policy smell. Every linter can detect blank lines and warn us. Tags Readability Long Methods Conclusion Empty lines are harmless, but show us an opportunity to break the code into small steps. If you break your code with comments, it is also a code smell asking for a refactor. It’s OK to figure out murder mysteries, but you shouldn’t need to figure out code.  You should be able to read it - Steve McConnell Code Smell 75 - Comments Inside a Method Comments are often a code smell. Inserting them inside a method calls for an urgent refactor. TL;DR Don't add comments inside your methods. Extract them and leave declarative comments just for not obvious design decisions. Problems Readability Kiss Low Reuse Bad Documentation Solutions Extract Method Refactor Remove not declarative comments. Sample Code Wrong function recoverFromGrief() {
    // Denial stage
    absorbTheBadNews();
    setNumbAsProtectiveState();
    startToRiseEmotions();
    feelSorrow();

    // Anger stage
    maskRealEffects();
    directAngerToOtherPeople();
    blameOthers();
    getIrrational();

    // bargaining stage
    feelVulnerable();
    regret();
    askWhyToMyself();
    dreamOfAlternativeWhatIfScenarios();
    postoponeSadness();

    // depression stage
    stayQuiet();
    getOverwhelmed();
    beConfused();

    // acceptance stage
    acceptWhatHappened();
    lookToTheFuture();
    reconstructAndWalktrough();
} Right function recoverFromGrief() {
    denialStage();
    angerStage();
    bargainingStage();
    depressionStage();
    acceptanceStage();
}

function denialStage() {
    absorbTheBadNews();
    setNumbAsProtectiveState();
    startToRiseEmotions();
    feelSorrow();
}

function angerStage() {
    maskRealEffects();
    directAngerToOtherPeople();
    blameOthers();
    getIrrational();
}

function bargainingStage() {
    feelVulnerable();
    regret();
    askWhyToMyself();
    dreamOfAlternativeWhatIfScenarios();
    postoponeSadness();
}

function depressionStage() {
    stayQuiet();
    getOverwhelmed();
    beConfused();
}

function acceptanceStage() {
    acceptWhatHappened();
    lookToTheFuture();
    reconstructAndWalktrough();
} Detection This is a policy smell. Every linter can detect comments not in the first line and warn us. Tags Readability Long Methods Comments Conclusion Comments are a code smell. If you need to document a design decision, you should do it before the actual method code. Relations Code Smell 03 - Functions Are Too Long Code Smell 74 - Empty Lines Code Smell 05 - Comment Abusers Don't get suckered in by the comments, they can be terribly misleading: Debug only the code - Dave Storer And that’s all for now… The next article will explain 5 more code smells!

How to Find The Stinky Parts of Your Code [Part XV]

AVR Microcontroller Testing Procedures

AOP Frameworks Can Do Wonders For Your Project — Here's How

Quartz is an open-source Java job scheduling framework that provides powerful capabilities for scheduling tasks. In DolphinScheduler, Quartz is used to implement task scheduling and management. DolphinScheduler integrates with Quartz through the QuartzExecutorImpl class, combining workflow and schedule management operations with Quartz's scheduling framework to achieve task execution. This article provides a detailed analysis of Quartz's principles and implementation within DolphinScheduler. Quartz Entity-Relationship Diagram QRTZ_JOB_DETAILS and QRTZ_TRIGGERS are the central tables, defining the relationship between jobs and triggers.


The QRTZ_TRIGGERS table links with multiple trigger-type tables, such as QRTZ_SIMPLE_TRIGGERS and QRTZ_CRON_TRIGGERS, to enable different trigger mechanisms.


QRTZ_FIRED_TRIGGERS records execution history, associating with both the job and trigger tables.


QRTZ_CALENDARS defines calendar exclusion rules for triggers, while QRTZ_PAUSED_TRIGGER_GRPS manages the pause state of trigger groups.


QRTZ_SCHEDULER_STATE and QRTZ_LOCKS are used for scheduling coordination in clustered environments, ensuring high availability. Quartz in DolphinScheduler We will focus on the principle analysis of the use of quartz in DolphinScheduler, so the steps for using quartz in DolphinScheduler will be introduced briefly. Generally speaking, there are 4 steps: Creating a New SHELL Task
Defining and Configuring Workflow Scheduling
Scheduling Activation
Workflow Instance Execution Principle Analysis Creating a Schedule org.apache.dolphinscheduler.api.controller.SchedulerController#createSchedule  
--org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#insertSchedule  
...  
Schedule scheduleObj = new Schedule();  
Date now = new Date();  
scheduleObj.setTenantCode(tenantCode);  
scheduleObj.setProjectName(project.getName());  
scheduleObj.setProcessDefinitionCode(processDefineCode);  
scheduleObj.setProcessDefinitionName(processDefinition.getName());  
ScheduleParam scheduleParam = JSONUtils.parseObject(schedule, ScheduleParam.class);  
scheduleObj.setCrontab(scheduleParam.getCrontab());  
scheduleObj.setTimezoneId(scheduleParam.getTimezoneId());  
scheduleObj.setWarningType(warningType);  
scheduleObj.setWarningGroupId(warningGroupId);  
scheduleObj.setFailureStrategy(failureStrategy);  
scheduleObj.setCreateTime(now);  
scheduleObj.setUpdateTime(now);  
scheduleObj.setUserId(loginUser.getId());  
scheduleObj.setUserName(loginUser.getUserName());  
scheduleObj.setReleaseState(ReleaseState.OFFLINE);  
scheduleObj.setProcessInstancePriority(processInstancePriority);  
scheduleObj.setWorkerGroup(workerGroup);  
scheduleObj.setEnvironmentCode(environmentCode);  
scheduleMapper.insert(scheduleObj);  
... At its core, this operation inserts a new entry into the schedule table, as shown below: Activating a Schedule org.apache.dolphinscheduler.api.controller.SchedulerController#publishScheduleOnline  
--org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#onlineScheduler  
----org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#doOnlineScheduler  
------org.apache.dolphinscheduler.scheduler.quartz.QuartzScheduler#insertOrUpdateScheduleTask  

// Simplified code:  
JobKey jobKey = QuartzTaskUtils.getJobKey(schedule.getId(), projectId);  
Map<String, Object> jobDataMap = QuartzTaskUtils.buildDataMap(projectId, schedule);  
String cronExpression = schedule.getCrontab();  
String timezoneId = schedule.getTimezoneId();  

Date startDate = DateUtils.transformTimezoneDate(schedule.getStartTime(), timezoneId);  
Date endDate = DateUtils.transformTimezoneDate(schedule.getEndTime(), timezoneId);  
JobDetail jobDetail = newJob(ProcessScheduleTask.class).withIdentity(jobKey).build();  
jobDetail.getJobDataMap().putAll(jobDataMap);  
scheduler.addJob(jobDetail, false, true);  

TriggerKey triggerKey = new TriggerKey(jobKey.getName(), jobKey.getGroup());  
CronTrigger cronTrigger = newTrigger()  
                    .withIdentity(triggerKey)  
                    .startAt(startDate)  
                    .endAt(endDate)  
                    .withSchedule(  
                            cronSchedule(cronExpression)  
                                    .withMisfireHandlingInstructionIgnoreMisfires()  
                                    .inTimeZone(DateUtils.getTimezone(timezoneId)))  
                    .forJob(jobDetail).build();  

scheduler.scheduleJob(cronTrigger); Related Tables Job Details Table: Stores detailed information about each task. Trigger Base Table: Stores basic information for all trigger types. Cron Trigger Table: Stores information about Cron expression triggers. Schedule Execution org.apache.dolphinscheduler.scheduler.quartz.ProcessScheduleTask

protected void executeInternal(JobExecutionContext context) {  
    JobDataMap dataMap = context.getJobDetail().getJobDataMap();  
    int projectId = dataMap.getInt(QuartzTaskUtils.PROJECT_ID);  
    int scheduleId = dataMap.getInt(QuartzTaskUtils.SCHEDULE_ID);  

    Date scheduledFireTime = context.getScheduledFireTime();  
    Date fireTime = context.getFireTime();  

    Command command = new Command();  
    command.setCommandType(CommandType.SCHEDULER);  
    command.setExecutorId(schedule.getUserId());  
    command.setFailureStrategy(schedule.getFailureStrategy());  
    command.setProcessDefinitionCode(schedule.getProcessDefinitionCode());  
    command.setScheduleTime(scheduledFireTime);  
    command.setStartTime(fireTime);  
    command.setWarningGroupId(schedule.getWarningGroupId());  
    String workerGroup = StringUtils.isEmpty(schedule.getWorkerGroup()) ? Constants.DEFAULT_WORKER_GROUP  
            : schedule.getWorkerGroup();  
    command.setWorkerGroup(workerGroup);  
    command.setTenantCode(schedule.getTenantCode());  
    command.setEnvironmentCode(schedule.getEnvironmentCode());  
    command.setWarningType(schedule.getWarningType());  
    command.setProcessInstancePriority(schedule.getProcessInstancePriority());  
    command.setProcessDefinitionVersion(processDefinition.getVersion());  

    commandService.createCommand(command);  
} Essentially, this is a callback function in Quartz that ultimately generates a Command. Quartz is an open-source Java job scheduling framework that provides powerful capabilities for scheduling tasks. In DolphinScheduler, Quartz is used to implement task scheduling and management. DolphinScheduler integrates with Quartz through the QuartzExecutorImpl class, combining workflow and schedule management operations with Quartz's scheduling framework to achieve task execution. QuartzExecutorImpl This article provides a detailed analysis of Quartz's principles and implementation within DolphinScheduler. Quartz Entity-Relationship Diagram QRTZ_JOB_DETAILS and QRTZ_TRIGGERS are the central tables, defining the relationship between jobs and triggers. The QRTZ_TRIGGERS table links with multiple trigger-type tables, such as QRTZ_SIMPLE_TRIGGERS and QRTZ_CRON_TRIGGERS, to enable different trigger mechanisms. QRTZ_FIRED_TRIGGERS records execution history, associating with both the job and trigger tables. QRTZ_CALENDARS defines calendar exclusion rules for triggers, while QRTZ_PAUSED_TRIGGER_GRPS manages the pause state of trigger groups. QRTZ_SCHEDULER_STATE and QRTZ_LOCKS are used for scheduling coordination in clustered environments, ensuring high availability. QRTZ_JOB_DETAILS and QRTZ_TRIGGERS are the central tables, defining the relationship between jobs and triggers. QRTZ_JOB_DETAILS and QRTZ_TRIGGERS are the central tables, defining the relationship between jobs and triggers. QRTZ_JOB_DETAILS QRTZ_TRIGGERS The QRTZ_TRIGGERS table links with multiple trigger-type tables, such as QRTZ_SIMPLE_TRIGGERS and QRTZ_CRON_TRIGGERS, to enable different trigger mechanisms. The QRTZ_TRIGGERS table links with multiple trigger-type tables, such as QRTZ_SIMPLE_TRIGGERS and QRTZ_CRON_TRIGGERS , to enable different trigger mechanisms. QRTZ_TRIGGERS QRTZ_SIMPLE_TRIGGERS QRTZ_CRON_TRIGGERS QRTZ_FIRED_TRIGGERS records execution history, associating with both the job and trigger tables. QRTZ_FIRED_TRIGGERS records execution history, associating with both the job and trigger tables. QRTZ_FIRED_TRIGGERS QRTZ_CALENDARS defines calendar exclusion rules for triggers, while QRTZ_PAUSED_TRIGGER_GRPS manages the pause state of trigger groups. QRTZ_CALENDARS defines calendar exclusion rules for triggers, while QRTZ_PAUSED_TRIGGER_GRPS manages the pause state of trigger groups. QRTZ_CALENDARS QRTZ_PAUSED_TRIGGER_GRPS QRTZ_SCHEDULER_STATE and QRTZ_LOCKS are used for scheduling coordination in clustered environments, ensuring high availability. QRTZ_SCHEDULER_STATE and QRTZ_LOCKS are used for scheduling coordination in clustered environments, ensuring high availability. QRTZ_SCHEDULER_STATE QRTZ_LOCKS Quartz in DolphinScheduler We will focus on the principle analysis of the use of quartz in DolphinScheduler, so the steps for using quartz in DolphinScheduler will be introduced briefly. Generally speaking, there are 4 steps: Creating a New SHELL Task Defining and Configuring Workflow Scheduling Scheduling Activation Workflow Instance Execution Creating a New SHELL Task Defining and Configuring Workflow Scheduling Scheduling Activation Workflow Instance Execution Principle Analysis Creating a Schedule org.apache.dolphinscheduler.api.controller.SchedulerController#createSchedule  
--org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#insertSchedule  
...  
Schedule scheduleObj = new Schedule();  
Date now = new Date();  
scheduleObj.setTenantCode(tenantCode);  
scheduleObj.setProjectName(project.getName());  
scheduleObj.setProcessDefinitionCode(processDefineCode);  
scheduleObj.setProcessDefinitionName(processDefinition.getName());  
ScheduleParam scheduleParam = JSONUtils.parseObject(schedule, ScheduleParam.class);  
scheduleObj.setCrontab(scheduleParam.getCrontab());  
scheduleObj.setTimezoneId(scheduleParam.getTimezoneId());  
scheduleObj.setWarningType(warningType);  
scheduleObj.setWarningGroupId(warningGroupId);  
scheduleObj.setFailureStrategy(failureStrategy);  
scheduleObj.setCreateTime(now);  
scheduleObj.setUpdateTime(now);  
scheduleObj.setUserId(loginUser.getId());  
scheduleObj.setUserName(loginUser.getUserName());  
scheduleObj.setReleaseState(ReleaseState.OFFLINE);  
scheduleObj.setProcessInstancePriority(processInstancePriority);  
scheduleObj.setWorkerGroup(workerGroup);  
scheduleObj.setEnvironmentCode(environmentCode);  
scheduleMapper.insert(scheduleObj);  
... org.apache.dolphinscheduler.api.controller.SchedulerController#createSchedule  
--org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#insertSchedule  
...  
Schedule scheduleObj = new Schedule();  
Date now = new Date();  
scheduleObj.setTenantCode(tenantCode);  
scheduleObj.setProjectName(project.getName());  
scheduleObj.setProcessDefinitionCode(processDefineCode);  
scheduleObj.setProcessDefinitionName(processDefinition.getName());  
ScheduleParam scheduleParam = JSONUtils.parseObject(schedule, ScheduleParam.class);  
scheduleObj.setCrontab(scheduleParam.getCrontab());  
scheduleObj.setTimezoneId(scheduleParam.getTimezoneId());  
scheduleObj.setWarningType(warningType);  
scheduleObj.setWarningGroupId(warningGroupId);  
scheduleObj.setFailureStrategy(failureStrategy);  
scheduleObj.setCreateTime(now);  
scheduleObj.setUpdateTime(now);  
scheduleObj.setUserId(loginUser.getId());  
scheduleObj.setUserName(loginUser.getUserName());  
scheduleObj.setReleaseState(ReleaseState.OFFLINE);  
scheduleObj.setProcessInstancePriority(processInstancePriority);  
scheduleObj.setWorkerGroup(workerGroup);  
scheduleObj.setEnvironmentCode(environmentCode);  
scheduleMapper.insert(scheduleObj);  
... At its core, this operation inserts a new entry into the schedule table, as shown below: schedule Activating a Schedule org.apache.dolphinscheduler.api.controller.SchedulerController#publishScheduleOnline  
--org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#onlineScheduler  
----org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#doOnlineScheduler  
------org.apache.dolphinscheduler.scheduler.quartz.QuartzScheduler#insertOrUpdateScheduleTask  

// Simplified code:  
JobKey jobKey = QuartzTaskUtils.getJobKey(schedule.getId(), projectId);  
Map<String, Object> jobDataMap = QuartzTaskUtils.buildDataMap(projectId, schedule);  
String cronExpression = schedule.getCrontab();  
String timezoneId = schedule.getTimezoneId();  

Date startDate = DateUtils.transformTimezoneDate(schedule.getStartTime(), timezoneId);  
Date endDate = DateUtils.transformTimezoneDate(schedule.getEndTime(), timezoneId);  
JobDetail jobDetail = newJob(ProcessScheduleTask.class).withIdentity(jobKey).build();  
jobDetail.getJobDataMap().putAll(jobDataMap);  
scheduler.addJob(jobDetail, false, true);  

TriggerKey triggerKey = new TriggerKey(jobKey.getName(), jobKey.getGroup());  
CronTrigger cronTrigger = newTrigger()  
                    .withIdentity(triggerKey)  
                    .startAt(startDate)  
                    .endAt(endDate)  
                    .withSchedule(  
                            cronSchedule(cronExpression)  
                                    .withMisfireHandlingInstructionIgnoreMisfires()  
                                    .inTimeZone(DateUtils.getTimezone(timezoneId)))  
                    .forJob(jobDetail).build();  

scheduler.scheduleJob(cronTrigger); org.apache.dolphinscheduler.api.controller.SchedulerController#publishScheduleOnline  
--org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#onlineScheduler  
----org.apache.dolphinscheduler.api.service.impl.SchedulerServiceImpl#doOnlineScheduler  
------org.apache.dolphinscheduler.scheduler.quartz.QuartzScheduler#insertOrUpdateScheduleTask  

// Simplified code:  
JobKey jobKey = QuartzTaskUtils.getJobKey(schedule.getId(), projectId);  
Map<String, Object> jobDataMap = QuartzTaskUtils.buildDataMap(projectId, schedule);  
String cronExpression = schedule.getCrontab();  
String timezoneId = schedule.getTimezoneId();  

Date startDate = DateUtils.transformTimezoneDate(schedule.getStartTime(), timezoneId);  
Date endDate = DateUtils.transformTimezoneDate(schedule.getEndTime(), timezoneId);  
JobDetail jobDetail = newJob(ProcessScheduleTask.class).withIdentity(jobKey).build();  
jobDetail.getJobDataMap().putAll(jobDataMap);  
scheduler.addJob(jobDetail, false, true);  

TriggerKey triggerKey = new TriggerKey(jobKey.getName(), jobKey.getGroup());  
CronTrigger cronTrigger = newTrigger()  
                    .withIdentity(triggerKey)  
                    .startAt(startDate)  
                    .endAt(endDate)  
                    .withSchedule(  
                            cronSchedule(cronExpression)  
                                    .withMisfireHandlingInstructionIgnoreMisfires()  
                                    .inTimeZone(DateUtils.getTimezone(timezoneId)))  
                    .forJob(jobDetail).build();  

scheduler.scheduleJob(cronTrigger); Related Tables Job Details Table: Stores detailed information about each task. Job Details Table: Trigger Base Table: Stores basic information for all trigger types. Trigger Base Table: Cron Trigger Table: Stores information about Cron expression triggers. Cron Trigger Table: Schedule Execution org.apache.dolphinscheduler.scheduler.quartz.ProcessScheduleTask

protected void executeInternal(JobExecutionContext context) {  
    JobDataMap dataMap = context.getJobDetail().getJobDataMap();  
    int projectId = dataMap.getInt(QuartzTaskUtils.PROJECT_ID);  
    int scheduleId = dataMap.getInt(QuartzTaskUtils.SCHEDULE_ID);  

    Date scheduledFireTime = context.getScheduledFireTime();  
    Date fireTime = context.getFireTime();  

    Command command = new Command();  
    command.setCommandType(CommandType.SCHEDULER);  
    command.setExecutorId(schedule.getUserId());  
    command.setFailureStrategy(schedule.getFailureStrategy());  
    command.setProcessDefinitionCode(schedule.getProcessDefinitionCode());  
    command.setScheduleTime(scheduledFireTime);  
    command.setStartTime(fireTime);  
    command.setWarningGroupId(schedule.getWarningGroupId());  
    String workerGroup = StringUtils.isEmpty(schedule.getWorkerGroup()) ? Constants.DEFAULT_WORKER_GROUP  
            : schedule.getWorkerGroup();  
    command.setWorkerGroup(workerGroup);  
    command.setTenantCode(schedule.getTenantCode());  
    command.setEnvironmentCode(schedule.getEnvironmentCode());  
    command.setWarningType(schedule.getWarningType());  
    command.setProcessInstancePriority(schedule.getProcessInstancePriority());  
    command.setProcessDefinitionVersion(processDefinition.getVersion());  

    commandService.createCommand(command);  
} org.apache.dolphinscheduler.scheduler.quartz.ProcessScheduleTask

protected void executeInternal(JobExecutionContext context) {  
    JobDataMap dataMap = context.getJobDetail().getJobDataMap();  
    int projectId = dataMap.getInt(QuartzTaskUtils.PROJECT_ID);  
    int scheduleId = dataMap.getInt(QuartzTaskUtils.SCHEDULE_ID);  

    Date scheduledFireTime = context.getScheduledFireTime();  
    Date fireTime = context.getFireTime();  

    Command command = new Command();  
    command.setCommandType(CommandType.SCHEDULER);  
    command.setExecutorId(schedule.getUserId());  
    command.setFailureStrategy(schedule.getFailureStrategy());  
    command.setProcessDefinitionCode(schedule.getProcessDefinitionCode());  
    command.setScheduleTime(scheduledFireTime);  
    command.setStartTime(fireTime);  
    command.setWarningGroupId(schedule.getWarningGroupId());  
    String workerGroup = StringUtils.isEmpty(schedule.getWorkerGroup()) ? Constants.DEFAULT_WORKER_GROUP  
            : schedule.getWorkerGroup();  
    command.setWorkerGroup(workerGroup);  
    command.setTenantCode(schedule.getTenantCode());  
    command.setEnvironmentCode(schedule.getEnvironmentCode());  
    command.setWarningType(schedule.getWarningType());  
    command.setProcessInstancePriority(schedule.getProcessInstancePriority());  
    command.setProcessDefinitionVersion(processDefinition.getVersion());  

    commandService.createCommand(command);  
} Essentially, this is a callback function in Quartz that ultimately generates a Command . Command

Stories, News & Mentions about GETIR

Getir’s Stories on HackerNoon

Getir's News & Mentions